@gitkraken/core-gitlens 0.1.0 → 0.2.0

package/src/git-cli/providers/branches.ts

@@ -99,7 +99,7 @@ export class BranchesGitSubProvider implements GitBranchesSubProvider {
 					? this.provider.pausedOps?.getPausedOperationStatus(repoPath, cancellation)
 					: undefined,
 				this.git
-					.exec(
+					.run(
 						{
 							cwd: repoPath,
 							cancellation: cancellation,
@@ -172,7 +172,7 @@ export class BranchesGitSubProvider implements GitBranchesSubProvider {
 				const parser = getBranchParser(supported);
 
 				const [gitResult, defaultWorktreePathResult, metadataMapResult] = await Promise.allSettled([
-					this.git.exec(
+					this.git.run(
 						{ cwd: commonPath, cancellation: signal },
 						'for-each-ref',
 						...parser.arguments,
@@ -365,50 +365,60 @@ export class BranchesGitSubProvider implements GitBranchesSubProvider {
 	): Promise<BranchContributionsOverview | undefined> {
 		const scope = getScopedLogger();
 
-		try {
-			const branch = await this.getBranch(repoPath, ref, cancellation);
-			if (branch == null) return undefined;
-
+		const getCore = async (
+			_commonPath: string,
+			_cacheable: CacheController | undefined,
+			signal: AbortSignal | undefined,
+			storedTarget: string | undefined,
+		): Promise<BranchContributionsOverview | undefined> => {
 			let mergeTarget: string | undefined;
 
-			// 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' });
 
@@ -446,6 +456,7 @@ export class BranchesGitSubProvider implements GitBranchesSubProvider {
 				branch: ref,
 				mergeTarget: mergeTarget,
 				mergeBase: mergeBase,
+				mergeBaseDate: mergeBaseDates?.committerDate,
 
 				commits: totalCommits,
 				files: totalFiles,
@@ -457,6 +468,23 @@ export class BranchesGitSubProvider implements GitBranchesSubProvider {
 
 				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);
 			if (isCancellationError(ex)) throw ex;
@@ -520,7 +548,7 @@ export class BranchesGitSubProvider implements GitBranchesSubProvider {
 			params.push(options.name);
 		}
 
-		return this.git.exec(
+		return this.git.run(
 			{
 				cwd: repoPath,
 				cancellation: cancellation,
@@ -563,7 +591,7 @@ export class BranchesGitSubProvider implements GitBranchesSubProvider {
 				let data: [string, string | undefined] | undefined;
 				let result;
 				try {
-					result = await this.git.exec(
+					result = await this.git.run(
 						{ cwd: repoPath, cancellation: signal, errors: 'throw' },
 						'rev-parse',
 						'--abbrev-ref',
@@ -582,7 +610,7 @@ export class BranchesGitSubProvider implements GitBranchesSubProvider {
 							data = [ex.stdout, undefined];
 						} else {
 							try {
-								result = await this.git.exec(
+								result = await this.git.run(
 									{ cwd: repoPath, cancellation: signal },
 									'symbolic-ref',
 									'--short',
@@ -629,7 +657,7 @@ export class BranchesGitSubProvider implements GitBranchesSubProvider {
 							}
 						}
 					} else if (GitWarnings.headNotABranch.test(msg)) {
-						result = await this.git.exec(
+						result = await this.git.run(
 							{
 								cwd: repoPath,
 								cancellation: signal,
@@ -687,7 +715,7 @@ export class BranchesGitSubProvider implements GitBranchesSubProvider {
 			let retried = false;
 			while (true) {
 				try {
-					const result = await this.git.exec(
+					const result = await this.git.run(
 						{ cwd: commonPath, cancellation: cancellation },
 						'symbolic-ref',
 						'--short',
@@ -699,7 +727,7 @@ export class BranchesGitSubProvider implements GitBranchesSubProvider {
 						try {
 							if (!retried) {
 								retried = true;
-								await this.git.exec(
+								await this.git.run(
 									{ cwd: commonPath, cancellation: cancellation },
 									'remote',
 									'set-head',
@@ -709,7 +737,7 @@ export class BranchesGitSubProvider implements GitBranchesSubProvider {
 								continue;
 							}
 
-							const result = await this.git.exec(
+							const result = await this.git.run(
 								{ cwd: commonPath, cancellation: cancellation },
 								'ls-remote',
 								'--symref',
@@ -741,7 +769,7 @@ export class BranchesGitSubProvider implements GitBranchesSubProvider {
 			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']);
 		} catch (ex) {
@@ -767,7 +795,7 @@ export class BranchesGitSubProvider implements GitBranchesSubProvider {
 		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']);
 		} catch (ex) {
@@ -795,7 +823,7 @@ export class BranchesGitSubProvider implements GitBranchesSubProvider {
 		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']);
 		} catch (ex) {
@@ -815,42 +843,67 @@ export class BranchesGitSubProvider implements GitBranchesSubProvider {
 	}
 
 	@debug()
-	async getBranchMergedStatus(
+	getBranchMergedStatus(
 		repoPath: string,
 		branch: GitBranchReference,
 		into: GitBranchReference,
 		cancellation?: AbortSignal,
 	): Promise<GitBranchMergedStatus> {
 		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;
+		// 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}`;
 
-		// 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,
-						}),
-					};
+		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,
+		);
 	}
 
 	private async getBranchMergedStatusCore(
@@ -864,7 +917,7 @@ export class BranchesGitSubProvider implements GitBranchesSubProvider {
 		try {
 			// Check if branch is direct ancestor (handles FF merges)
 			try {
-				await this.git.exec(
+				await this.git.run(
 					{ cwd: repoPath, cancellation: cancellation, errors: 'throw' },
 					'merge-base',
 					'--is-ancestor',
@@ -877,7 +930,7 @@ export class BranchesGitSubProvider implements GitBranchesSubProvider {
 			}
 
 			// Cherry-pick detection (handles cherry-picks, rebases, etc)
-			let result = await this.git.exec(
+			let result = await this.git.run(
 				{ cwd: repoPath, cancellation: cancellation },
 				'cherry',
 				'--abbrev',
@@ -904,7 +957,7 @@ export class BranchesGitSubProvider implements GitBranchesSubProvider {
 				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) {
 				// Create a temporary index file
 				await using disposableIndex = await this.provider.staging.createTemporaryIndex(
@@ -914,7 +967,7 @@ export class BranchesGitSubProvider implements GitBranchesSubProvider {
 				);
 				const { env } = disposableIndex;
 
-				result = await this.git.exec(
+				result = await this.git.run(
 					{
 						cwd: repoPath,
 						cancellation: cancellation,
@@ -977,7 +1030,7 @@ export class BranchesGitSubProvider implements GitBranchesSubProvider {
 				const parentRefs = shas.map(c => `${c}^`);
 				let parentShas: string[];
 				try {
-					const result = await this.git.exec(
+					const result = await this.git.run(
 						{ cwd: repoPath, cancellation: signal, errors: 'throw' },
 						'rev-parse',
 						...parentRefs,
@@ -1022,7 +1075,7 @@ export class BranchesGitSubProvider implements GitBranchesSubProvider {
 
 				let data;
 				try {
-					const result = await this.git.exec(
+					const result = await this.git.run(
 						{ cwd: repoPath, cancellation: signal, errors: 'throw' },
 						'merge-tree',
 						'-z',
@@ -1095,7 +1148,7 @@ export class BranchesGitSubProvider implements GitBranchesSubProvider {
 		let currentTreeOid: string;
 		try {
 			// Get the initial target branch tree OID
-			const treeResult = await this.git.exec(
+			const treeResult = await this.git.run(
 				{ cwd: repoPath, cancellation: cancellation, errors: 'throw' },
 				'rev-parse',
 				`${targetBranch}^{tree}`,
@@ -1121,7 +1174,7 @@ export class BranchesGitSubProvider implements GitBranchesSubProvider {
 				//   - 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(
+				const result = await this.git.run(
 					{ cwd: repoPath, cancellation: cancellation, errors: 'throw' },
 					'merge-tree',
 					'--write-tree',
@@ -1210,36 +1263,43 @@ export class BranchesGitSubProvider implements GitBranchesSubProvider {
 	}
 
 	@debug({ exit: true })
-	async getBaseBranchName(repoPath: string, ref: string, cancellation?: AbortSignal): Promise<string | undefined> {
-		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;
-			}
+	getBaseBranchName(repoPath: string, ref: string, cancellation?: AbortSignal): Promise<string | 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(repoPath, mergeBase);
-				if (branch != null) {
-					if (update) {
-						void this.storeBaseBranchName(repoPath, ref, branch);
+					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;
+						}
 					}
+				} catch {}
+
+				const branch = await this.getBaseBranchFromReflog(commonPath, ref, { upstream: true }, signal);
+				if (branch != null) {
+					void this.storeBaseBranchName(commonPath, ref, 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;
+				return undefined;
+			},
+			cancellation,
+		);
 	}
 
 	private async getBaseBranchFromReflog(
@@ -1249,7 +1309,7 @@ export class BranchesGitSubProvider implements GitBranchesSubProvider {
 		cancellation?: AbortSignal,
 	): Promise<string | undefined> {
 		try {
-			let result = await this.git.exec(
+			let result = await this.git.run(
 				{ cwd: repoPath, cancellation: cancellation },
 				'reflog',
 				ref,
@@ -1275,7 +1335,7 @@ export class BranchesGitSubProvider implements GitBranchesSubProvider {
 			}
 
 			// Check if branch was created from HEAD
-			result = await this.git.exec(
+			result = await this.git.run(
 				{ cwd: repoPath, cancellation: cancellation },
 				'reflog',
 				'HEAD',
@@ -1347,11 +1407,21 @@ export class BranchesGitSubProvider implements GitBranchesSubProvider {
 		await this.storeBranchMetadata(repoPath, 'gk-last-modified', branch.name, now);
 	}
 
+	/** Updates the agent last activity timestamp for the current branch */
+	@debounce(2.5 * 60 * 1000)
+	@debug()
+	async onCurrentBranchAgentActivity(repoPath: string): Promise<void> {
+		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());
+	}
+
 	@debug()
 	async renameBranch(repoPath: string, oldName: string, newName: string): Promise<void> {
 		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']);
 		} catch (ex) {
@@ -1377,7 +1447,7 @@ export class BranchesGitSubProvider implements GitBranchesSubProvider {
 		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']);
 		} catch (ex) {
@@ -1417,56 +1487,60 @@ export class BranchesGitSubProvider implements GitBranchesSubProvider {
 	 * Gets all branch metadata (dates and disposition) from git config in a single batch operation.
 	 * @returns A map of branch name to metadata.
 	 */
-	private async getBranchMetadataMap(repoPath: string): Promise<Map<string, BranchMetadata>> {
-		const scope = getScopedLogger();
-		const metadataMap = new Map<string, BranchMetadata>();
+	private getBranchMetadataMap(repoPath: string): Promise<Map<string, BranchMetadata>> {
+		return this.cache.getBranchMetadataMap(repoPath, async commonPath => {
+			const scope = getScopedLogger();
+			const metadataMap = new Map<string, BranchMetadata>();
 
-		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;
+			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;
+				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;
+					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('.');
+					// 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);
-				}
+					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;
+					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);
 			}
-		} catch (ex) {
-			debugger;
-			scope?.error(ex);
-		}
 
-		return metadataMap;
+			return metadataMap;
+		});
 	}
 
 	private async storeBranchMetadata(
 		repoPath: string,
-		key: 'gk-last-accessed' | 'gk-last-modified',
+		key: 'gk-last-accessed' | 'gk-last-modified' | 'gk-agent-last-activity',
 		ref: string,
 		date: Date,
 	): Promise<void> {