@gitkraken/core-gitlens 0.1.0 → 0.3.0

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

@@ -75,7 +75,6 @@ import { getSettledValue } from '../../utils/promise.js';
 import { maybeStopWatch } from '../../utils/stopwatch.js';
 import { getGitCommandError, gitConfigsBranch, gitConfigsLog, GitError, GitErrors, GitWarnings } from '../exec/git.js';
 import { parseMergeTreeConflict } from '../parsers/mergeTreeParser.js';
-import { getBranchParser } from '../parsers/refParser.js';
 /** Minimum time between writes to the config for last accessed/modified dates */
 const dateMetadataStaleThresholdMs = 5 * 60 * 1000; // 5 minutes
 export class BranchesGitSubProvider {
@@ -110,10 +109,10 @@ export class BranchesGitSubProvider {
             return undefined;
         const [pausedOpStatusResult, committerDateResult, defaultWorktreePathResult, metadataMapResult] = await Promise.allSettled([
             isDetachedHead(ref.name)
-                ? this.provider.pausedOps?.getPausedOperationStatus(repoPath, cancellation)
+                ? this.provider.pausedOps?.getPausedOperationStatus(repoPath, undefined, cancellation)
                 : undefined,
             this.git
-                .exec({
+                .run({
                 cwd: repoPath,
                 cancellation: cancellation,
                 configs: gitConfigsLog,
@@ -147,32 +146,37 @@ export class BranchesGitSubProvider {
             try {
                 const env_1 = { stack: [], error: void 0, hasError: false };
                 try {
-                    const supported = await this.git.supported('git:for-each-ref');
-                    const parser = getBranchParser(supported);
-                    const [gitResult, defaultWorktreePathResult, metadataMapResult] = await Promise.allSettled([
-                        this.git.exec({ cwd: commonPath, cancellation: signal }, 'for-each-ref', ...parser.arguments, 'refs/heads/', 'refs/remotes/'),
+                    const [recordsResult, supportedResult, defaultWorktreePathResult, metadataMapResult] = await Promise.allSettled([
+                        this.provider.refs.getRefs(commonPath, signal),
+                        this.git.supported('git:for-each-ref'),
                         this.provider.config.getDefaultWorktreePath?.(commonPath),
                         this.getBranchMetadataMap(commonPath),
                     ]);
-                    const result = getSettledValue(gitResult);
+                    const records = getSettledValue(recordsResult) ?? [];
+                    const supported = getSettledValue(supportedResult) ?? [];
                     const metadataMap = getSettledValue(metadataMapResult) ?? new Map();
                     const defaultWorktreePath = getSettledValue(defaultWorktreePathResult);
+                    const worktreePathSupported = supported.includes('git:for-each-ref:worktreePath');
                     // If we don't get any data, assume the repo doesn't have any commits yet so check if we have a current branch
-                    if (!result?.stdout) {
+                    if (!records.length) {
                         const current = await this.getCurrentBranch(commonPath, metadataMap, options?.ordering ?? this.context.config?.commits.ordering ?? undefined, signal);
                         return current != null ? { values: [current] } : emptyPagedResult;
                     }
                     const sw = __addDisposableResource(env_1, maybeStopWatch(scope, { log: { onlyExit: true, level: 'debug' } }), false);
                     const branches = [];
-                    for (const entry of parser.parse(result.stdout)) {
+                    for (const record of records) {
+                        const fullName = record.name;
+                        // Filter to branches and remote-tracking branches; skip tags from the unified records.
+                        if (!fullName.startsWith('refs/heads/') && !fullName.startsWith('refs/remotes/'))
+                            continue;
                         // Skip HEAD refs in remote branches
-                        if (isRemoteHEAD(entry.name))
+                        if (isRemoteHEAD(fullName))
                             continue;
-                        const upstream = parseUpstream(entry.upstream, entry.upstreamTracking);
-                        const metadata = metadataMap.get(parseRefName(entry.name).name);
-                        const worktreePath = entry.worktreePath ? normalizePath(entry.worktreePath) : undefined;
-                        branches.push(new GitBranch(commonPath, entry.name, false, // Don't trust %(HEAD) for current as it's per-worktree -- we will set it later
-                        entry.date ? new Date(entry.date) : undefined, metadata, entry.sha, upstream, supported.includes('git:for-each-ref:worktreePath')
+                        const upstream = parseUpstream(record.upstream, record.upstreamTracking);
+                        const metadata = metadataMap.get(parseRefName(fullName).name);
+                        const worktreePath = record.worktreePath ? normalizePath(record.worktreePath) : undefined;
+                        branches.push(new GitBranch(commonPath, fullName, false, // Don't trust %(HEAD) for current as it's per-worktree -- we will set it later
+                        record.committerDate ? new Date(record.committerDate) : undefined, metadata, record.objectname, upstream, worktreePathSupported
                             ? worktreePath
                                 ? { path: worktreePath, isDefault: worktreePath === defaultWorktreePath }
                                 : false
@@ -286,35 +290,25 @@ export class BranchesGitSubProvider {
     }
     async getBranchContributionsOverview(repoPath, ref, options, cancellation) {
         const scope = getScopedLogger();
-        try {
-            const branch = await this.getBranch(repoPath, ref, cancellation);
-            if (branch == null)
-                return undefined;
-            let mergeTarget;
-            // Tier 1: Check stored merge target (user-set or previously detected from PR)
-            const storedTarget = await this.getStoredMergeTargetBranchName(repoPath, ref);
-            if (storedTarget) {
-                const validated = await this.provider.refs.getSymbolicReferenceName(repoPath, storedTarget);
-                mergeTarget = validated || storedTarget;
-            }
-            // Tier 2: PR-based lookup (caller provides the PR promise)
-            if (mergeTarget == null && options?.associatedPullRequest != null) {
-                const pr = await options.associatedPullRequest;
-                if (pr?.refs?.base != null) {
-                    mergeTarget = `${branch.remoteName}/${pr.refs.base.branch}`;
-                    // Store for future reuse
-                    void this.storeMergeTargetBranchName(repoPath, ref, mergeTarget);
-                }
-            }
-            // Tier 3: Base branch, then default branch
-            mergeTarget ??= await this.getBaseBranchName(repoPath, ref, cancellation);
-            mergeTarget ??= await this.getDefaultBranchName(repoPath, undefined, cancellation);
-            if (mergeTarget == null)
-                return undefined;
-            const mergeBase = await this.provider.refs.getMergeBase(repoPath, ref, mergeTarget, undefined, cancellation);
+        const priority = options?.priority;
+        const priorityOpts = priority != null ? { priority: priority } : undefined;
+        // Expensive body — runs only on cache miss. Closes over `mergeTarget` so the cache key
+        // (`${ref}|${mergeTarget}`) fully captures every input that affects the result.
+        const fetchBody = async (mergeTarget, signal) => {
+            const mergeBase = await this.provider.refs.getMergeBase(repoPath, ref, mergeTarget, priorityOpts, signal);
             if (mergeBase == null)
                 return undefined;
-            const result = await this.provider.contributors.getContributors(repoPath, createRevisionRange(mergeBase, ref, '..'), { stats: true }, cancellation);
+            // Fetch the merge-base commit's dates in parallel with contributors so consumers
+            // (e.g. the graph minimap scope window) don't pay a separate round-trip for them.
+            // `allSettled` so a transient failure in one side doesn't drop the overview entirely.
+            const [contributorsSettled, mergeBaseDatesSettled] = await Promise.allSettled([
+                this.provider.contributors.getContributors(repoPath, createRevisionRange(mergeBase, ref, '..'), { stats: true }, signal),
+                this.provider.commits.getCommitDates(repoPath, mergeBase, signal),
+            ]);
+            if (signal?.aborted)
+                throw new CancellationError();
+            const result = getSettledValue(contributorsSettled) ?? { contributors: [] };
+            const mergeBaseDates = getSettledValue(mergeBaseDatesSettled);
             sortContributors(result.contributors, { orderBy: 'score:desc' });
             let totalCommits = 0;
             let totalFiles = 0;
@@ -345,6 +339,7 @@ export class BranchesGitSubProvider {
                 branch: ref,
                 mergeTarget: mergeTarget,
                 mergeBase: mergeBase,
+                mergeBaseDate: mergeBaseDates?.committerDate,
                 commits: totalCommits,
                 files: totalFiles,
                 additions: totalAdditions,
@@ -353,6 +348,49 @@ export class BranchesGitSubProvider {
                 firstCommitDate: firstCommitTimestamp != null ? new Date(firstCommitTimestamp) : undefined,
                 contributors: result.contributors,
             };
+        };
+        try {
+            // Resolve `mergeTarget` through Tier 1 → Tier 2 → Tier 3. The pieces of each tier are
+            // already individually cached (`getStoredMergeTargetBranchName`, `getBaseBranchName`,
+            // `getDefaultBranchName`), so this resolution path is cheap on warm caches. Only the
+            // expensive body below (`getMergeBase` + `getContributors` w/ stats + `getCommitDates`)
+            // is wrapped by `cache.getBranchOverview`, keyed on the resolved `mergeTarget` so any
+            // caller that resolves to the same target shares; differing targets get independent
+            // slots, which is the correctness constraint that previously forced the Tier 2/3 paths
+            // to bypass the cache entirely.
+            let mergeTarget;
+            // Tier 1: Stored merge target (user-set or previously detected from PR).
+            const storedTarget = await this.getStoredMergeTargetBranchName(repoPath, ref);
+            if (storedTarget) {
+                const validated = await this.provider.refs.getSymbolicReferenceName(repoPath, storedTarget, priorityOpts, cancellation);
+                mergeTarget = validated || storedTarget;
+            }
+            // Tier 2: PR-based lookup. The branch object is only needed here (for `remoteName`),
+            // so lazy-load it on the cold path instead of paying for it on every call.
+            if (mergeTarget == null && options?.associatedPullRequest != null) {
+                const pr = await options.associatedPullRequest;
+                if (pr?.refs?.base != null) {
+                    const branch = await this.getBranch(repoPath, ref, cancellation);
+                    if (branch == null)
+                        return undefined;
+                    mergeTarget = `${branch.remoteName}/${pr.refs.base.branch}`;
+                    // Store for future reuse — turns the next call into a Tier 1 path. Skip the
+                    // `branchOverviews` invalidation that the write would otherwise trigger: we're
+                    // about to populate `${ref}|${mergeTarget}` with this exact target, so evicting
+                    // it would just force the next caller to redo the body. (gk-merge-target writes
+                    // do not affect `baseBranchName`, so no need to skip that target.)
+                    void this.storeMergeTargetBranchName(repoPath, ref, mergeTarget, {
+                        skipInvalidation: ['branchOverviews'],
+                    });
+                }
+            }
+            // Tier 3: Base branch, then default branch.
+            mergeTarget ??= await this.getBaseBranchName(repoPath, ref, priorityOpts, cancellation);
+            mergeTarget ??= await this.getDefaultBranchName(repoPath, undefined, priorityOpts, cancellation);
+            if (mergeTarget == null)
+                return undefined;
+            const resolvedTarget = mergeTarget;
+            return await this.cache.getBranchOverview(repoPath, `${ref}|${resolvedTarget}`, (_commonPath, _cacheable, signal) => fetchBody(resolvedTarget, signal ?? cancellation), { cancellation: cancellation });
         }
         catch (ex) {
             scope?.error(ex);
@@ -387,7 +425,7 @@ export class BranchesGitSubProvider {
         if (options?.name != null) {
             params.push(options.name);
         }
-        return this.git.exec({
+        return this.git.run({
             cwd: repoPath,
             cancellation: cancellation,
             configs: gitConfigsBranch,
@@ -414,7 +452,7 @@ export class BranchesGitSubProvider {
             let data;
             let result;
             try {
-                result = await this.git.exec({ cwd: repoPath, cancellation: signal, errors: 'throw' }, 'rev-parse', '--abbrev-ref', '--symbolic-full-name', '@', '@{u}', '--');
+                result = await this.git.run({ cwd: repoPath, cancellation: signal, errors: 'throw' }, 'rev-parse', '--abbrev-ref', '--symbolic-full-name', '@', '@{u}', '--');
                 data = [result.stdout, undefined];
             }
             catch (ex) {
@@ -427,7 +465,7 @@ export class BranchesGitSubProvider {
                     }
                     else {
                         try {
-                            result = await this.git.exec({ cwd: repoPath, cancellation: signal }, 'symbolic-ref', '--short', 'HEAD');
+                            result = await this.git.run({ cwd: repoPath, cancellation: signal }, 'symbolic-ref', '--short', 'HEAD');
                             if (result.stdout) {
                                 data = [result.stdout.trim(), undefined];
                             }
@@ -437,7 +475,7 @@ export class BranchesGitSubProvider {
                                 throw ex;
                         }
                         if (data == null) {
-                            const symbolicRef = await this.getDefaultBranchName(repoPath, 'origin', signal);
+                            const symbolicRef = await this.getDefaultBranchName(repoPath, 'origin', undefined, signal);
                             if (symbolicRef != null) {
                                 data = [
                                     symbolicRef.startsWith('origin/')
@@ -463,7 +501,7 @@ export class BranchesGitSubProvider {
                     }
                 }
                 else if (GitWarnings.headNotABranch.test(msg)) {
-                    result = await this.git.exec({
+                    result = await this.git.run({
                         cwd: repoPath,
                         cancellation: signal,
                         configs: gitConfigsLog,
@@ -494,15 +532,17 @@ export class BranchesGitSubProvider {
             });
         }, { cancellation: cancellation });
     }
-    async getDefaultBranchName(repoPath, remote, cancellation) {
+    async getDefaultBranchName(repoPath, remote, options, cancellation) {
         if (repoPath == null)
             return undefined;
         remote ??= 'origin';
+        const priority = options?.priority;
+        const priorityOpts = priority != null ? { priority: priority } : undefined;
         return this.cache.getDefaultBranchName(repoPath, remote, async (commonPath) => {
             let retried = false;
             while (true) {
                 try {
-                    const result = await this.git.exec({ cwd: commonPath, cancellation: cancellation }, 'symbolic-ref', '--short', `refs/remotes/${remote}/HEAD`);
+                    const result = await this.git.run({ cwd: commonPath, cancellation: cancellation, ...priorityOpts }, 'symbolic-ref', '--short', `refs/remotes/${remote}/HEAD`);
                     return result.stdout.trim() || undefined;
                 }
                 catch (ex) {
@@ -510,10 +550,10 @@ export class BranchesGitSubProvider {
                         try {
                             if (!retried) {
                                 retried = true;
-                                await this.git.exec({ cwd: commonPath, cancellation: cancellation }, 'remote', 'set-head', '-a', remote);
+                                await this.git.run({ cwd: commonPath, cancellation: cancellation, ...priorityOpts }, 'remote', 'set-head', '-a', remote);
                                 continue;
                             }
-                            const result = await this.git.exec({ cwd: commonPath, cancellation: cancellation }, 'ls-remote', '--symref', remote, 'HEAD');
+                            const result = await this.git.run({ cwd: commonPath, cancellation: cancellation, ...priorityOpts }, 'ls-remote', '--symref', remote, 'HEAD');
                             if (result.stdout) {
                                 const match = /ref:\s(\S+)\s+HEAD/m.exec(result.stdout);
                                 if (match != null) {
@@ -538,7 +578,7 @@ export class BranchesGitSubProvider {
             args.push('--no-track');
         }
         try {
-            await this.git.exec({ cwd: repoPath }, ...args);
+            await this.git.run({ cwd: repoPath }, ...args);
             this.context.hooks?.cache?.onReset?.(repoPath, 'branches');
             this.context.hooks?.repository?.onChanged?.(repoPath, ['heads']);
         }
@@ -555,7 +595,7 @@ export class BranchesGitSubProvider {
         const branches = ensureArray(names);
         const args = ['branch', options?.force ? '-D' : '-d', ...branches];
         try {
-            await this.git.exec({ cwd: repoPath }, ...args);
+            await this.git.run({ cwd: repoPath }, ...args);
             this.context.hooks?.cache?.onReset?.(repoPath, 'branches');
             this.context.hooks?.repository?.onChanged?.(repoPath, ['heads']);
         }
@@ -578,7 +618,7 @@ export class BranchesGitSubProvider {
         const branches = ensureArray(names);
         const args = ['push', '-d', remote, ...branches];
         try {
-            await this.git.exec({ cwd: repoPath }, ...args);
+            await this.git.run({ cwd: repoPath }, ...args);
             this.context.hooks?.cache?.onReset?.(repoPath, 'branches');
             this.context.hooks?.repository?.onChanged?.(repoPath, ['remotes']);
         }
@@ -593,42 +633,55 @@ export class BranchesGitSubProvider {
             throw new BranchError({ action: 'delete', branch: branches.join(', '), gitCommand: { repoPath: repoPath, args: args } }, ex);
         }
     }
-    async getBranchMergedStatus(repoPath, branch, into, cancellation) {
+    getBranchMergedStatus(repoPath, branch, into, cancellation) {
         if (branch.name === into.name || branch.upstream?.name === into.name) {
-            return { merged: false };
+            return Promise.resolve({ merged: false });
         }
-        const result = await this.getBranchMergedStatusCore(repoPath, branch, into, cancellation);
-        if (result.merged)
-            return result;
-        // If the branch we are checking is a remote branch, check if it has been merged into its local branch (if there is one)
-        if (into.remote) {
-            const localIntoBranch = await this.getLocalBranchByUpstream(repoPath, into.name, cancellation);
-            // If there is a local branch and it is not the branch we are checking, check if it has been merged into it
-            if (localIntoBranch != null && localIntoBranch.name !== branch.name) {
-                const result = await this.getBranchMergedStatusCore(repoPath, branch, localIntoBranch, cancellation);
-                if (result.merged) {
-                    return {
-                        ...result,
-                        localBranchOnly: createReference(localIntoBranch.ref, localIntoBranch.repoPath, {
-                            id: localIntoBranch.id,
-                            refType: 'branch',
-                            name: localIntoBranch.name,
-                            remote: localIntoBranch.remote,
-                            upstream: localIntoBranch.upstream,
-                            sha: localIntoBranch.sha,
-                        }),
-                    };
+        // Cache key omits repoPath so worktrees of the same common repo share the cached answer.
+        // Branch refs (`refs/heads/*` / `refs/remotes/*`) are unique within a common repo, so
+        // `name` + `remote` flag is the minimal stable identity.
+        const cacheKey = `${branch.remote ? 'r' : 'l'}:${branch.name}|${into.remote ? 'r' : 'l'}:${into.name}`;
+        return this.cache.getBranchMergedStatus(repoPath, cacheKey, async (commonPath, _cacheable, signal) => {
+            const result = await this.getBranchMergedStatusCore(commonPath, branch, into, signal);
+            if (result.merged)
+                return result;
+            // If the branch we are checking is a remote branch, check if it has been merged into its local branch (if there is one)
+            if (into.remote) {
+                const localIntoBranch = await this.getLocalBranchByUpstream(commonPath, into.name, signal);
+                // If there is a local branch and it is not the branch we are checking, check if it has been merged into it
+                if (localIntoBranch != null && localIntoBranch.name !== branch.name) {
+                    // Skip the second full merge-check cycle when the local branch points at the same commit as the remote —
+                    // the merge-base/cherry/diff/apply pipeline would produce the same answer we already got for `into` above
+                    if (localIntoBranch.sha != null && localIntoBranch.sha === into.sha) {
+                        return { merged: false };
+                    }
+                    const result = await this.getBranchMergedStatusCore(commonPath, branch, localIntoBranch, signal);
+                    if (result.merged) {
+                        // `localBranchOnly` is built against `commonPath` here; the cache mapper rewrites
+                        // `repoPath`/`id` to the requesting worktree on retrieval.
+                        return {
+                            ...result,
+                            localBranchOnly: createReference(localIntoBranch.ref, localIntoBranch.repoPath, {
+                                id: localIntoBranch.id,
+                                refType: 'branch',
+                                name: localIntoBranch.name,
+                                remote: localIntoBranch.remote,
+                                upstream: localIntoBranch.upstream,
+                                sha: localIntoBranch.sha,
+                            }),
+                        };
+                    }
                 }
             }
-        }
-        return { merged: false };
+            return { merged: false };
+        }, cancellation);
     }
     async getBranchMergedStatusCore(repoPath, branch, into, cancellation) {
         const scope = getScopedLogger();
         try {
             // Check if branch is direct ancestor (handles FF merges)
             try {
-                await this.git.exec({ cwd: repoPath, cancellation: cancellation, errors: 'throw' }, 'merge-base', '--is-ancestor', branch.name, into.name);
+                await this.git.run({ cwd: repoPath, cancellation: cancellation, errors: 'throw' }, 'merge-base', '--is-ancestor', branch.name, into.name);
                 return { merged: true, confidence: 'highest' };
             }
             catch (ex) {
@@ -636,7 +689,7 @@ export class BranchesGitSubProvider {
                     throw ex;
             }
             // Cherry-pick detection (handles cherry-picks, rebases, etc)
-            let result = await this.git.exec({ cwd: repoPath, cancellation: cancellation }, 'cherry', '--abbrev', '-v', into.name, branch.name);
+            let result = await this.git.run({ cwd: repoPath, cancellation: cancellation }, 'cherry', '--abbrev', '-v', into.name, branch.name);
             // Check if there are no lines or all lines startwith a `-` (i.e. likely merged)
             if (!result.stdout ||
                 result.stdout
@@ -647,14 +700,14 @@ export class BranchesGitSubProvider {
             }
             // Attempt to detect squash merges by checking if the diff of the branch can be cleanly removed from the target
             const mergeBase = await this.provider.refs.getMergeBase(repoPath, into.name, branch.name, undefined, cancellation);
-            result = await this.git.exec({ cwd: repoPath, cancellation: cancellation }, 'diff', mergeBase, branch.name);
+            result = await this.git.run({ cwd: repoPath, cancellation: cancellation }, 'diff', mergeBase, branch.name);
             if (result.stdout) {
                 const env_2 = { stack: [], error: void 0, hasError: false };
                 try {
                     // Create a temporary index file
                     const disposableIndex = __addDisposableResource(env_2, await this.provider.staging.createTemporaryIndex(repoPath, 'ref', into.name), true);
                     const { env } = disposableIndex;
-                    result = await this.git.exec({
+                    result = await this.git.run({
                         cwd: repoPath,
                         cancellation: cancellation,
                         env: env,
@@ -700,7 +753,7 @@ export class BranchesGitSubProvider {
             const parentRefs = shas.map(c => `${c}^`);
             let parentShas;
             try {
-                const result = await this.git.exec({ cwd: repoPath, cancellation: signal, errors: 'throw' }, 'rev-parse', ...parentRefs);
+                const result = await this.git.run({ cwd: repoPath, cancellation: signal, errors: 'throw' }, 'rev-parse', ...parentRefs);
                 parentShas = result.stdout.trim().split('\n');
             }
             catch (ex) {
@@ -727,7 +780,7 @@ export class BranchesGitSubProvider {
             }
             let data;
             try {
-                const result = await this.git.exec({ cwd: repoPath, cancellation: signal, errors: 'throw' }, 'merge-tree', '-z', '--name-only', '--no-messages', branch, targetBranch);
+                const result = await this.git.run({ cwd: repoPath, cancellation: signal, errors: 'throw' }, 'merge-tree', '-z', '--name-only', '--no-messages', branch, targetBranch);
                 data = result.stdout;
             }
             catch (ex) {
@@ -780,7 +833,7 @@ export class BranchesGitSubProvider {
         let currentTreeOid;
         try {
             // Get the initial target branch tree OID
-            const treeResult = await this.git.exec({ cwd: repoPath, cancellation: cancellation, errors: 'throw' }, 'rev-parse', `${targetBranch}^{tree}`);
+            const treeResult = await this.git.run({ cwd: repoPath, cancellation: cancellation, errors: 'throw' }, 'rev-parse', `${targetBranch}^{tree}`);
             currentTreeOid = treeResult.stdout.trim();
         }
         catch (ex) {
@@ -802,7 +855,7 @@ export class BranchesGitSubProvider {
                 //   - base = commit.parent (where the commit started)
                 //   - ours = currentTreeOid (current state of the target)
                 //   - theirs = commit.sha (what we're cherry-picking)
-                const result = await this.git.exec({ cwd: repoPath, cancellation: cancellation, errors: 'throw' }, 'merge-tree', '--write-tree', '-z', '--name-only', '--no-messages', `--merge-base=${commit.parent}`, currentTreeOid, commit.sha);
+                const result = await this.git.run({ cwd: repoPath, cancellation: cancellation, errors: 'throw' }, 'merge-tree', '--write-tree', '-z', '--name-only', '--no-messages', `--merge-base=${commit.parent}`, currentTreeOid, commit.sha);
                 data = result.stdout;
             }
             catch (ex) {
@@ -872,37 +925,51 @@ export class BranchesGitSubProvider {
         }
         return { status: 'clean' };
     }
-    async getBaseBranchName(repoPath, ref, cancellation) {
-        try {
-            // getGkConfig has built-in fallback to regular config for backward compatibility
-            let mergeBase = await this.provider.config.getGkConfig(repoPath, `branch.${ref}.gk-merge-base`);
-            let update = false;
-            // Also check vscode-merge-base in regular config (VS Code compatibility)
-            if (mergeBase == null) {
-                mergeBase = await this.provider.config.getConfig(repoPath, `branch.${ref}.vscode-merge-base`);
-                update = mergeBase != null;
-            }
-            if (mergeBase != null) {
-                const branch = await this.provider.refs.getSymbolicReferenceName(repoPath, mergeBase);
-                if (branch != null) {
-                    if (update) {
-                        void this.storeBaseBranchName(repoPath, ref, branch);
+    getBaseBranchName(repoPath, ref, options, cancellation) {
+        const priority = options?.priority;
+        const priorityOpts = priority != null ? { priority: priority } : undefined;
+        return this.cache.getBaseBranchName(repoPath, ref, async (commonPath, signal) => {
+            try {
+                // getGkConfig has built-in fallback to regular config for backward compatibility
+                let mergeBase = await this.provider.config.getGkConfig(commonPath, `branch.${ref}.gk-merge-base`);
+                let update = false;
+                // Also check vscode-merge-base in regular config (VS Code compatibility)
+                if (mergeBase == null) {
+                    mergeBase = await this.provider.config.getConfig(commonPath, `branch.${ref}.vscode-merge-base`);
+                    update = mergeBase != null;
+                }
+                if (mergeBase != null) {
+                    const branch = await this.provider.refs.getSymbolicReferenceName(commonPath, mergeBase, priorityOpts);
+                    if (branch != null) {
+                        if (update) {
+                            // Self-write: the value we're storing is exactly what this factory is
+                            // returning, so any in-flight `branchOverviews` or `baseBranchName` entry
+                            // being populated against this resolution should NOT be evicted.
+                            void this.storeBaseBranchName(commonPath, ref, branch, {
+                                skipInvalidation: ['branchOverviews', 'baseBranchName'],
+                            });
+                        }
+                        return branch;
                     }
-                    return branch;
                 }
             }
-        }
-        catch { }
-        const branch = await this.getBaseBranchFromReflog(repoPath, ref, { upstream: true }, cancellation);
-        if (branch != null) {
-            void this.storeBaseBranchName(repoPath, ref, branch);
-            return branch;
-        }
-        return undefined;
+            catch { }
+            const branch = await this.getBaseBranchFromReflog(commonPath, ref, { upstream: true, priority: priority }, signal);
+            if (branch != null) {
+                // Self-write: see comment on the migration path above.
+                void this.storeBaseBranchName(commonPath, ref, branch, {
+                    skipInvalidation: ['branchOverviews', 'baseBranchName'],
+                });
+                return branch;
+            }
+            return undefined;
+        }, cancellation);
     }
     async getBaseBranchFromReflog(repoPath, ref, options, cancellation) {
+        const priority = options?.priority;
+        const priorityOpts = priority != null ? { priority: priority } : undefined;
         try {
-            let result = await this.git.exec({ cwd: repoPath, cancellation: cancellation }, 'reflog', ref, '--grep-reflog=branch: Created from *.');
+            let result = await this.git.run({ cwd: repoPath, cancellation: cancellation, ...priorityOpts }, 'reflog', ref, '--grep-reflog=branch: Created from *.');
             let entries = result.stdout.split('\n').filter(entry => Boolean(entry));
             if (entries.length !== 1)
                 return undefined;
@@ -912,17 +979,17 @@ export class BranchesGitSubProvider {
                 let name = match[1];
                 if (name !== 'HEAD') {
                     if (options?.upstream) {
-                        const upstream = await this.provider.refs.getSymbolicReferenceName(repoPath, `${name}@{u}`);
+                        const upstream = await this.provider.refs.getSymbolicReferenceName(repoPath, `${name}@{u}`, priorityOpts);
                         if (upstream)
                             return upstream;
                     }
-                    name = await this.provider.refs.getSymbolicReferenceName(repoPath, name);
+                    name = await this.provider.refs.getSymbolicReferenceName(repoPath, name, priorityOpts);
                     if (name)
                         return name;
                 }
             }
             // Check if branch was created from HEAD
-            result = await this.git.exec({ cwd: repoPath, cancellation: cancellation }, 'reflog', 'HEAD', `--grep-reflog=checkout: moving from .* to ${ref.replace('refs/heads/', '')}`);
+            result = await this.git.run({ cwd: repoPath, cancellation: cancellation, ...priorityOpts }, 'reflog', 'HEAD', `--grep-reflog=checkout: moving from .* to ${ref.replace('refs/heads/', '')}`);
             entries = result.stdout.split('\n').filter(entry => Boolean(entry));
             if (!entries.length)
                 return undefined;
@@ -930,11 +997,11 @@ export class BranchesGitSubProvider {
             if (match?.length === 2) {
                 let name = match[1];
                 if (options?.upstream) {
-                    const upstream = await this.provider.refs.getSymbolicReferenceName(repoPath, `${name}@{u}`);
+                    const upstream = await this.provider.refs.getSymbolicReferenceName(repoPath, `${name}@{u}`, priorityOpts);
                     if (upstream)
                         return upstream;
                 }
-                name = await this.provider.refs.getSymbolicReferenceName(repoPath, name);
+                name = await this.provider.refs.getSymbolicReferenceName(repoPath, name, priorityOpts);
                 if (name)
                     return name;
             }
@@ -975,10 +1042,17 @@ export class BranchesGitSubProvider {
         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, new Date());
+    }
     async renameBranch(repoPath, oldName, newName) {
         const args = ['branch', '-m', oldName, newName];
         try {
-            await this.git.exec({ cwd: repoPath }, ...args);
+            await this.git.run({ cwd: repoPath }, ...args);
             this.context.hooks?.cache?.onReset?.(repoPath, 'branches');
             this.context.hooks?.repository?.onChanged?.(repoPath, ['heads']);
         }
@@ -994,7 +1068,7 @@ export class BranchesGitSubProvider {
     async setUpstreamBranch(repoPath, name, upstream) {
         const args = upstream == null ? ['branch', '--unset-upstream', name] : ['branch', '--set-upstream-to', upstream, name];
         try {
-            await this.git.exec({ cwd: repoPath }, ...args);
+            await this.git.run({ cwd: repoPath }, ...args);
             this.context.hooks?.cache?.onReset?.(repoPath, 'branches');
             this.context.hooks?.repository?.onChanged?.(repoPath, ['heads']);
         }
@@ -1007,11 +1081,11 @@ export class BranchesGitSubProvider {
             }, ex));
         }
     }
-    async storeBaseBranchName(repoPath, ref, base) {
-        await this.provider.config.setGkConfig(repoPath, `branch.${ref}.gk-merge-base`, base);
+    async storeBaseBranchName(repoPath, ref, base, options) {
+        await this.provider.config.setGkConfig(repoPath, `branch.${ref}.gk-merge-base`, base, options);
     }
-    async storeMergeTargetBranchName(repoPath, ref, target) {
-        await this.provider.config.setGkConfig(repoPath, `branch.${ref}.gk-merge-target`, target);
+    async storeMergeTargetBranchName(repoPath, ref, target, options) {
+        await this.provider.config.setGkConfig(repoPath, `branch.${ref}.gk-merge-target`, target, options);
     }
     async storeUserMergeTargetBranchName(repoPath, ref, target) {
         await this.provider.config.setGkConfig(repoPath, `branch.${ref}.gk-merge-target-user`, target);
@@ -1020,47 +1094,52 @@ export class BranchesGitSubProvider {
      * Gets all branch metadata (dates and disposition) from git config in a single batch operation.
      * @returns A map of branch name to metadata.
      */
-    async getBranchMetadataMap(repoPath) {
-        const scope = getScopedLogger();
-        const metadataMap = new Map();
-        try {
-            // Use git config --get-regexp to load all gk-* branch metadata in one call
-            const configMap = await this.provider.config.getGkConfigRegex(repoPath, '^branch\\..*\\.gk-(last-(accessed|modified)|disposition)$');
-            if (!configMap.size)
-                return metadataMap;
-            for (const [key, value] of configMap) {
-                // Extract branch name and metadata key from "branch.{name}.gk-{key}"
-                if (!key.startsWith('branch.'))
-                    continue;
-                const keyParts = key.split('.');
-                if (keyParts.length < 3)
-                    continue;
-                // Branch name is everything between "branch." and the last ".gk-*"
-                const metaKey = keyParts.at(-1);
-                const branchName = keyParts.slice(1, -1).join('.');
-                let metadata = metadataMap.get(branchName);
-                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-disposition') {
-                    if (value === 'starred' || value === 'archived') {
-                        metadata.disposition = value;
+    getBranchMetadataMap(repoPath) {
+        return this.cache.getBranchMetadataMap(repoPath, async (commonPath) => {
+            const scope = getScopedLogger();
+            const metadataMap = new Map();
+            try {
+                // Use git config --get-regexp to load all gk-* branch metadata in one call
+                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) {
+                    // Extract branch name and metadata key from "branch.{name}.gk-{key}"
+                    if (!key.startsWith('branch.'))
+                        continue;
+                    const keyParts = key.split('.');
+                    if (keyParts.length < 3)
+                        continue;
+                    // Branch name is everything between "branch." and the last ".gk-*"
+                    const metaKey = keyParts.at(-1);
+                    const branchName = keyParts.slice(1, -1).join('.');
+                    let metadata = metadataMap.get(branchName);
+                    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;
+                        }
                     }
                 }
             }
-        }
-        catch (ex) {
-            debugger;
-            scope?.error(ex);
-        }
-        return metadataMap;
+            catch (ex) {
+                debugger;
+                scope?.error(ex);
+            }
+            return metadataMap;
+        });
     }
     async storeBranchMetadata(repoPath, key, ref, date) {
         const value = await this.provider.config.getGkConfig(repoPath, `branch.${ref}.${key}`);
@@ -1135,6 +1214,10 @@ __decorate([
     debounce(2.5 * 60 * 1000),
     debug()
 ], BranchesGitSubProvider.prototype, "onCurrentBranchModified", null);
+__decorate([
+    debounce(2.5 * 60 * 1000),
+    debug()
+], BranchesGitSubProvider.prototype, "onCurrentBranchAgentActivity", null);
 __decorate([
     debug()
 ], BranchesGitSubProvider.prototype, "renameBranch", null);