@gitkraken/core-gitlens 0.1.0 → 0.2.0

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

@@ -113,7 +113,7 @@ export class BranchesGitSubProvider {
                 ? this.provider.pausedOps?.getPausedOperationStatus(repoPath, cancellation)
                 : undefined,
             this.git
-                .exec({
+                .run({
                 cwd: repoPath,
                 cancellation: cancellation,
                 configs: gitConfigsLog,
@@ -150,7 +150,7 @@ export class BranchesGitSubProvider {
                     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/'),
+                        this.git.run({ cwd: commonPath, cancellation: signal }, 'for-each-ref', ...parser.arguments, 'refs/heads/', 'refs/remotes/'),
                         this.provider.config.getDefaultWorktreePath?.(commonPath),
                         this.getBranchMetadataMap(commonPath),
                     ]);
@@ -286,35 +286,46 @@ 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;
+        const getCore = async (_commonPath, _cacheable, signal, storedTarget) => {
             let mergeTarget;
-            // Tier 1: Check stored merge target (user-set or previously detected from PR)
-            const storedTarget = await this.getStoredMergeTargetBranchName(repoPath, ref);
+            // Tier 1: Stored merge target (user-set or previously detected from PR). Caller has
+            // already read this once for the cache decision; reuse rather than re-fetching.
             if (storedTarget) {
                 const validated = await this.provider.refs.getSymbolicReferenceName(repoPath, storedTarget);
                 mergeTarget = validated || storedTarget;
             }
-            // Tier 2: PR-based lookup (caller provides the PR promise)
+            // 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, signal);
+                    if (branch == null)
+                        return undefined;
                     mergeTarget = `${branch.remoteName}/${pr.refs.base.branch}`;
-                    // Store for future reuse
+                    // Store for future reuse — turns the next call into a Tier 1 cache-eligible path.
                     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);
+            mergeTarget ??= await this.getBaseBranchName(repoPath, ref, signal);
+            mergeTarget ??= await this.getDefaultBranchName(repoPath, undefined, signal);
             if (mergeTarget == null)
                 return undefined;
-            const mergeBase = await this.provider.refs.getMergeBase(repoPath, ref, mergeTarget, undefined, cancellation);
+            const mergeBase = await this.provider.refs.getMergeBase(repoPath, ref, mergeTarget, undefined, 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 +356,7 @@ export class BranchesGitSubProvider {
                 branch: ref,
                 mergeTarget: mergeTarget,
                 mergeBase: mergeBase,
+                mergeBaseDate: mergeBaseDates?.committerDate,
                 commits: totalCommits,
                 files: totalFiles,
                 additions: totalAdditions,
@@ -353,6 +365,16 @@ export class BranchesGitSubProvider {
                 firstCommitDate: firstCommitTimestamp != null ? new Date(firstCommitTimestamp) : undefined,
                 contributors: result.contributors,
             };
+        };
+        try {
+            // Pre-check Tier 1: when a stored merge target exists the result is deterministic for
+            // `ref` (Tier 2's PR resolution is short-circuited), so it's safe to cache. Otherwise
+            // the result depends on PR resolution which the cache key can't capture — bypass.
+            const storedTarget = await this.getStoredMergeTargetBranchName(repoPath, ref);
+            if (storedTarget != null) {
+                return await this.cache.getBranchOverview(repoPath, ref, (commonPath, cacheable, signal) => getCore(commonPath, cacheable, signal ?? cancellation, storedTarget), { cancellation: cancellation });
+            }
+            return await getCore(repoPath, undefined, cancellation, undefined);
         }
         catch (ex) {
             scope?.error(ex);
@@ -387,7 +409,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 +436,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 +449,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];
                             }
@@ -463,7 +485,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,
@@ -502,7 +524,7 @@ export class BranchesGitSubProvider {
             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 }, 'symbolic-ref', '--short', `refs/remotes/${remote}/HEAD`);
                     return result.stdout.trim() || undefined;
                 }
                 catch (ex) {
@@ -510,10 +532,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 }, '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 }, 'ls-remote', '--symref', remote, 'HEAD');
                             if (result.stdout) {
                                 const match = /ref:\s(\S+)\s+HEAD/m.exec(result.stdout);
                                 if (match != null) {
@@ -538,7 +560,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 +577,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 +600,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 +615,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 +671,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 +682,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 +735,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 +762,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 +815,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 +837,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 +907,39 @@ 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, cancellation) {
+        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);
+                    if (branch != null) {
+                        if (update) {
+                            void this.storeBaseBranchName(commonPath, ref, branch);
+                        }
+                        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 }, signal);
+            if (branch != null) {
+                void this.storeBaseBranchName(commonPath, ref, branch);
+                return branch;
+            }
+            return undefined;
+        }, cancellation);
     }
     async getBaseBranchFromReflog(repoPath, ref, options, cancellation) {
         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 }, 'reflog', ref, '--grep-reflog=branch: Created from *.');
             let entries = result.stdout.split('\n').filter(entry => Boolean(entry));
             if (entries.length !== 1)
                 return undefined;
@@ -922,7 +959,7 @@ export class BranchesGitSubProvider {
                 }
             }
             // 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 }, '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;
@@ -975,10 +1012,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 +1038,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']);
         }
@@ -1020,47 +1064,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 +1184,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);