Fix Git ref refresh resource storms#4727

merged8

main

t3code/git-ref-refresh-resource-storm

openedJul 28, 2026byJJulius Marminge

View on GitHubTwo-way sync enabledPR last imported 4d ago

25 unresolved threads · Jump to file

apps/web/src/state/paginatedBranches.ts:35 · ### Branch pages stuck without scroll **High Severity**  Branch paginati
packages/client-runtime/src/state/vcs.ts:123 · ### Reconnect refetch skips server refresh **Medium Severity**  On each
apps/server/src/vcs/GitVcsDriverCore.ts:2283 · ### Current branch never marked **Medium Severity**  `current` is set on
packages/client-runtime/src/state/vcsRefInvalidation.ts:66 · ### Clear failure still rehydrates stale cache **Medium Severity**  When
apps/server/src/vcs/GitVcsDriverCore.ts:246 · 🟡 **Medium** `vcs/GitVcsDriverCore.ts:246` `parseWorktreeBranchPaths` splits `git worktree list --
apps/web/src/state/paginatedBranches.ts:31–31 · 🟡 **Medium** `state/paginatedBranches.ts:31` `shouldLoadNextBranchPageAfterScroll` never loads the
packages/client-runtime/src/state/vcs.ts:90 · ### Late refresh repersists stale refs **Medium Severity**  An in-flight
packages/client-runtime/src/state/vcs.ts:297 · ### Failed mutations skip ref invalidation **High Severity**  Several mu
apps/server/src/vcs/GitVcsDriverCore.ts:2344 · ### Coalesced refresh ignores invalidation **Medium Severity**  A `listR
packages/client-runtime/src/state/vcsRefInvalidation.ts:52 · ### Cross-worktree stale persisted refs **Medium Severity**  The `invali
apps/server/src/vcs/GitVcsDriverCore.ts:236 · 🟡 **Medium** `vcs/GitVcsDriverCore.ts:236` `parseWorktreeBranchPaths` returns worktree paths witho
apps/server/src/vcs/GitVcsDriverCore.ts:2195 · ### Ignored for-each-ref failures **High Severity**  `readGitRefsSnapsho
packages/client-runtime/src/state/vcsAction.ts:497 · ### Failed stacked actions skip ref invalidation **Medium Severity**  `r
packages/client-runtime/src/state/vcs.ts · File comment · 🟡 **Medium** https://github.com/pingdotgg/t3code/blob/25c0c7abc81393ea9f52fb054823b928589327ba/pac
packages/client-runtime/src/state/vcsRefInvalidation.ts:39 · 🟡 **Medium** `state/vcsRefInvalidation.ts:39` `invalidateVcsRefs` makes `persistedCacheReadable` s
packages/client-runtime/src/state/vcs.ts:291 · ### Refresh status skips ref invalidation **Medium Severity**  `refreshS
packages/client-runtime/src/state/vcs.ts:185 · ### Ref invalidation misses list cwd **Medium Severity**  `invalidateRef
packages/client-runtime/src/state/vcs.ts:124 · ### Pull leaves ref lists stale **Medium Severity**  Replacing the five-
packages/client-runtime/src/state/vcsRefInvalidation.ts:53–55 · 🟡 **Medium** `state/vcsRefInvalidation.ts:53` `invalidateCachedVcsRefs` bumps the revision atom be
apps/server/src/vcs/GitVcsDriverCore.ts:2348 · ### Stale cached current branch **Medium Severity**  `listRefs` rebuilds
packages/client-runtime/src/state/vcs.ts:154 · 🟡 **Medium** `state/vcs.ts:154` `invalidateRefs` only deletes the persisted cache entry for the `c
packages/client-runtime/src/state/vcs.ts:243 · ### Stacked commits skip ref invalidation **High Severity**  The new mut
apps/server/src/vcs/GitVcsDriverCore.ts:1109 · ### Backoff cleared on failed fetch **Medium Severity**  `refreshStatusR
packages/client-runtime/src/state/vcs.ts:92 · ### Stale refs after refresh failure **Medium Severity**  The refs strea
packages/client-runtime/src/state/vcs.ts:93 · ### Stale persisted refs after invalidation **Medium Severity**  After a

Selected thread: packages/client-runtime/src/state/vcsRefInvalidation.ts:55 — 🟡 **Medium** `state/vcsRefInvalidation.ts:53` `invalidateCachedVcsRefs` bumps the revision atom before `cache.clearVcsRefs` finishes, so active ref streams restart synchronously, call `loadVcsRefs` outside the lock, and emit the stale persisted snapshot before it is deleted. After a successful Git mutation, users can temporarily be shown the pre-mutation branch list. Swap the order so the cache is cleared before the revision is published — the surrounding persistence lock already prevents stale refresh writes. ```suggestion yield* cache.clearVcsRefs(target.environmentId).pipe( Effect.catch((error) => Effect.logWarning("Could not remove invalidated cached Git refs.").pipe( Effect.annotateLogs({ environmentId: target.environmentId, cwd: target.cwd, ...safeErrorLogAttributes(error), }), ), ), ); invalidateVcsRefs(registry, target); ``` <details> <summary>🚀 Reply "<strong>fix it for me</strong>" or copy this <strong>AI Prompt</strong> for your agent:</summary> ```text In file @packages/client-runtime/src/state/vcsRefInvalidation.ts around lines 53-55: `invalidateCachedVcsRefs` bumps the revision atom before `cache.clearVcsRefs` finishes, so active ref streams restart synchronously, call `loadVcsRefs` outside the lock, and emit the stale persisted snapshot before it is deleted. After a successful Git mutation, users can temporarily be shown the pre-mutation branch list. Swap the order so the cache is cleared before the revision is published — the surrounding persistence lock already prevents stale refresh writes. ``` </details>

0 / 25 viewed25 files changedLine totals unavailable

packages/client-runtime/src/state/vcs.ts · Earlier revision 8fb87fd7 · left 123

Original diff

@@ -104,34 +104,30 @@ export const makeCachedVcsRefsChanges = Effect.fn("CachedVcsRefsState.makeChange
   ).pipe(
     Stream.map((connection) => (connection.phase === "connected" ? connection.generation : null)),
     Stream.changes,
-    Stream.switchMap((generation) =>
-      generation === null
-        ? Stream.empty
-        : Stream.tick(VCS_REFS_REVALIDATE_INTERVAL).pipe(
-            Stream.mapEffect(
-              () =>
-                refresh().pipe(
-                  Effect.map(Option.some),
-                  Effect.catch((error) =>
-                    Effect.logWarning("Could not refresh Git refs.").pipe(
-                      Effect.annotateLogs({
-                        environmentId,
-                        cwd: input.cwd,
-                        ...safeErrorLogAttributes(error),
-                      }),
-                      Effect.as(Option.none<VcsListRefsResult>()),
-                    ),

cursorBotJul 28, 2026

Reconnect refetch skips server refresh

Medium Severity

On each connection-generation refetch, makeCachedVcsRefsChanges calls vcs.listRefs with the subscribed input unchanged. Atoms that omit refresh: true (for example DiffPanel local/remote base-ref queries with refKind and includeMatchingRemoteRefs) now receive cached server snapshots for up to two minutes instead of a Git rescan. Removing the five-second poll makes out-of-band ref updates visible much later on those paths.

Fix in Cursor Fix in Web

^{Reviewed by Cursor Bugbot for commit 8fb87fd77be389089c439e78bb82e25c66d843bc. Configure here.}

apps/server/src/vcs/GitVcsDriverCore.ts · Earlier revision 8fb87fd7 · right 2283

Original diff

@@ -1987,257 +2070,226 @@ export const makeGitVcsDriverCore = Effect.fn("makeGitVcsDriverCore")(function*
       Effect.map((trimmed) => (trimmed.length > 0 ? trimmed : null)),
     );
 
-  const listRefs: GitVcsDriver.GitVcsDriver["Service"]["listRefs"] = Effect.fn("listRefs")(
-    function* (input) {
-      const branchRecencyPromise = readBranchRecency(input.cwd).pipe(
-        Effect.orElseSucceed(() => new Map<string, number>()),
-      );
-      const localBranchResult = yield* executeGitWithStableDiagnostics(
-        "GitVcsDriver.listRefs.branchNoColor",
-        input.cwd,
-        ["branch", "--no-color", "--no-column"],
-        {
-          timeoutMs: 10_000,
+  const readGitRefsSnapshot = Effect.fn("readGitRefsSnapshot")(function* (gitCommonDir: string) {
+    const fetchCwd =
+      path.basename(gitCommonDir) === ".git" ? path.dirname(gitCommonDir) : gitCommonDir;
+    const gitDirArgs = ["--git-dir", gitCommonDir] as const;
+    const [refsResult, defaultRefResult, worktreeListResult, remoteNamesResult] = yield* Effect.all(
+      [
+        executeGitWithStableDiagnostics(
+          "GitVcsDriver.listRefs.snapshotRefs",
+          fetchCwd,
+          [
+            ...gitDirArgs,
+            "for-each-ref",
+            "--format=%(refname)%09%(committerdate:unix)%09%(symref)",
+            "refs/heads",
+            "refs/remotes",
+          ],
+          {
+            timeoutMs: 30_000,
+            maxOutputBytes: 16 * 1024 * 1024,
+          },
+        ),
+        executeGit(
+          "GitVcsDriver.listRefs.defaultRef",
+          fetchCwd,
+          [...gitDirArgs, "symbolic-ref", "refs/remotes/origin/HEAD"],
+          {
+            timeoutMs: 5_000,
+            allowNonZeroExit: true,
+          },
+        ),
+        executeGit(
+          "GitVcsDriver.listRefs.worktreeList",
+          fetchCwd,
+          [...gitDirArgs, "worktree", "list", "--porcelain"],
+          {
+            timeoutMs: 30_000,
+            allowNonZeroExit: true,
+            maxOutputBytes: 16 * 1024 * 1024,
+          },
+        ),
+        executeGit("GitVcsDriver.listRefs.remoteNames", fetchCwd, [...gitDirArgs, "remote"], {
+          timeoutMs: 5_000,
           allowNonZeroExit: true,
-        },
-      ).pipe(
-        Effect.catchTags({
-          GitCommandError: (error) =>
-            isMissingGitCwdError(error)
-              ? Effect.succeed({
-                  exitCode: ChildProcessSpawner.ExitCode(128),
-                  stdout: "",
-                  stderr: "fatal: not a git repository",
-                  stdoutTruncated: false,
-                  stderrTruncated: false,
-                })
-              : Effect.fail(error),
         }),
-      );
+      ],
+      { concurrency: 2 },
+    );
 
-      if (localBranchResult.exitCode !== 0) {
-        const stderr = localBranchResult.stderr.trim();
-        if (isNonRepositoryGitStderr(stderr)) {
-          return {
-            refs: [],
-            isRepo: false,
-            hasPrimaryRemote: false,
-            nextCursor: null,
-            totalCount: 0,
-          };
-        }
-        return yield* new GitCommandError({
-          ...gitCommandContext({
-            operation: "GitVcsDriver.listRefs",
-            cwd: input.cwd,
-            args: ["branch", "--no-color", "--no-column"],
-          }),
-          detail: "Git branch listing failed.",
-          exitCode: localBranchResult.exitCode,
-          stdoutLength: localBranchResult.stdout.length,
-          stderrLength: localBranchResult.stderr.length,
+    const remoteNames =
+      remoteNamesResult.exitCode === 0 ? parseRemoteNames(remoteNamesResult.stdout) : [];
+    if (remoteNamesResult.exitCode !== 0 && remoteNamesResult.stderr.trim().length > 0) {
+      yield* Effect.logWarning(
+        `GitVcsDriver.listRefs: remote name lookup returned code ${remoteNamesResult.exitCode} for ${gitCommonDir}: ${remoteNamesResult.stderr.trim()}. Falling back to an empty remote name list.`,
+      );
+    }
+    const defaultBranch =
+      defaultRefResult.exitCode === 0
+        ? defaultRefResult.stdout.trim().replace(/^refs\/remotes\/origin\//, "")
+        : null;
+    const worktreeMap =
+      worktreeListResult.exitCode === 0
+        ? new Map(
+            [...parseWorktreeBranchPaths(worktreeListResult.stdout)].map(
+              ([branchName, worktreePath]) =>
+                [branchName, path.normalize(path.resolve(worktreePath))] as const,
+            ),
+          )
+        : new Map<string, string>();
+    const localBranches: Array<{ readonly ref: VcsRef; readonly lastCommit: number }> = [];
+    const remoteBranches: Array<{ readonly ref: VcsRef; readonly lastCommit: number }> = [];
+
+    for (const line of refsResult.stdout.split("\n")) {
+      if (line.length === 0) continue;
+      const [fullRefName, lastCommitRaw, symbolicTarget] = line.split("\t");
+      if (!fullRefName || symbolicTarget) continue;
+      const parsedLastCommit = Number.parseInt(lastCommitRaw ?? "0", 10);
+      const lastCommit = Number.isFinite(parsedLastCommit) ? parsedLastCommit : 0;
+
+      if (fullRefName.startsWith("refs/heads/")) {
+        const name = fullRefName.slice("refs/heads/".length);
+        localBranches.push({
+          ref: {
+            name,
+            current: false,
+            isRemote: false,
+            isDefault: name === defaultBranch,
+            worktreePath: worktreeMap.get(name) ?? null,
+          },
+          lastCommit,
         });
+        continue;
       }
+      if (!fullRefName.startsWith("refs/remotes/")) continue;
+
+      const name = fullRefName.slice("refs/remotes/".length);
+      const parsedRemoteRef = parseRemoteRefWithRemoteNames(name, remoteNames);
+      const remoteBranch: VcsRef = {
+        name,
+        current: false,
+        isRemote: true,
+        isDefault:
+          defaultBranch !== null &&
+          parsedRemoteRef?.remoteName === "origin" &&
+          parsedRemoteRef.branchName === defaultBranch,
+        worktreePath: null,
+        ...(parsedRemoteRef ? { remoteName: parsedRemoteRef.remoteName } : {}),
+      };
+      remoteBranches.push({ ref: remoteBranch, lastCommit });
+    }
 
-      const remoteBranchResultEffect = executeGit(
-        "GitVcsDriver.listRefs.remoteBranches",
-        input.cwd,
-        ["branch", "--no-color", "--no-column", "--remotes"],
-        {
-          timeoutMs: 10_000,
-          allowNonZeroExit: true,
-        },
-      ).pipe(
-        Effect.catchTags({
-          GitCommandError: (error) =>
-            Effect.logWarning(
-              "Git remote ref lookup failed; falling back to an empty remote ref list.",
-              {
-                operation: error.operation,
-                command: error.command,
-                cwd: error.cwd,
-                detail: error.detail,
-                cause: error,
-              },
-            ).pipe(
-              Effect.as({
-                exitCode: ChildProcessSpawner.ExitCode(1),
-                stdout: "",
-                stderr: "",
-                stdoutTruncated: false,
-                stderrTruncated: false,
-              } satisfies GitVcsDriver.ExecuteGitResult),
-            ),
-        }),
-      );
-
-      const remoteNamesResultEffect = executeGit(
-        "GitVcsDriver.listRefs.remoteNames",
-        input.cwd,
-        ["remote"],
-        {
-          timeoutMs: 5_000,
-          allowNonZeroExit: true,
-        },
-      ).pipe(
-        Effect.catchTags({
-          GitCommandError: (error) =>
-            Effect.logWarning(
-              "Git remote name lookup failed; falling back to an empty remote name list.",
-              {
-                operation: error.operation,
-                command: error.command,
-                cwd: error.cwd,
-                detail: error.detail,
-                cause: error,
-              },
-            ).pipe(
-              Effect.as({
-                exitCode: ChildProcessSpawner.ExitCode(1),
-                stdout: "",
-                stderr: "",
-                stdoutTruncated: false,
-                stderrTruncated: false,
-              } satisfies GitVcsDriver.ExecuteGitResult),
-            ),
-        }),
-      );
+    const byRecencyThenName = (
+      left: { readonly ref: VcsRef; readonly lastCommit: number },
+      right: { readonly ref: VcsRef; readonly lastCommit: number },
+    ) =>
+      left.lastCommit !== right.lastCommit
+        ? right.lastCommit - left.lastCommit
+        : left.ref.name.localeCompare(right.ref.name);
 
-      const [defaultRef, worktreeList, remoteBranchResult, remoteNamesResult, branchLastCommit] =
-        yield* Effect.all(
-          [
-            executeGit(
-              "GitVcsDriver.listRefs.defaultRef",
-              input.cwd,
-              ["symbolic-ref", "refs/remotes/origin/HEAD"],
-              {
-                timeoutMs: 5_000,
-                allowNonZeroExit: true,
-              },
-            ),
-            executeGit(
-              "GitVcsDriver.listRefs.worktreeList",
-              input.cwd,
-              ["worktree", "list", "--porcelain"],
-              {
-                timeoutMs: 5_000,
-                allowNonZeroExit: true,
-              },
-            ),
-            remoteBranchResultEffect,
-            remoteNamesResultEffect,
-            branchRecencyPromise,
-          ],
-          { concurrency: "unbounded" },
-        );
+    return {
+      localBranches: localBranches.toSorted(byRecencyThenName).map(({ ref }) => ref),
+      remoteBranches: remoteBranches.toSorted(byRecencyThenName).map(({ ref }) => ref),
+      hasPrimaryRemote: remoteNames.includes("origin"),
+    } satisfies GitRefsSnapshot;
+  });
 
-      const remoteNames =
-        remoteNamesResult.exitCode === 0 ? parseRemoteNames(remoteNamesResult.stdout) : [];
-      if (remoteBranchResult.exitCode !== 0 && remoteBranchResult.stderr.trim().length > 0) {
-        yield* Effect.logWarning(
-          `GitVcsDriver.listRefs: remote refName lookup returned code ${remoteBranchResult.exitCode} for ${input.cwd}: ${remoteBranchResult.stderr.trim()}. Falling back to an empty remote refName list.`,
-        );
+  const listRefsEpochByCommonDir = new Map<string, number>();
+  let listRefsEpochSequence = 0;
+  const bumpListRefsEpoch = (gitCommonDir: string): number => {
+    const nextEpoch = ++listRefsEpochSequence;
+    listRefsEpochByCommonDir.delete(gitCommonDir);
+    listRefsEpochByCommonDir.set(gitCommonDir, nextEpoch);
+    if (listRefsEpochByCommonDir.size > LIST_REFS_SNAPSHOT_CACHE_CAPACITY) {
+      const oldestKey = listRefsEpochByCommonDir.keys().next().value;
+      if (oldestKey !== undefined) {
+        listRefsEpochByCommonDir.delete(oldestKey);
       }
-      if (remoteNamesResult.exitCode !== 0 && remoteNamesResult.stderr.trim().length > 0) {
-        yield* Effect.logWarning(
-          `GitVcsDriver.listRefs: remote name lookup returned code ${remoteNamesResult.exitCode} for ${input.cwd}: ${remoteNamesResult.stderr.trim()}. Falling back to an empty remote name list.`,
+    }
+    return nextEpoch;
+  };
+  const listRefsSnapshotCache = yield* Cache.makeWith(
+    (cacheKey: GitRefsSnapshotCacheKey) => readGitRefsSnapshot(cacheKey.gitCommonDir),
+    {
+      capacity: LIST_REFS_SNAPSHOT_CACHE_CAPACITY,
+      timeToLive: (exit) => (Exit.isSuccess(exit) ? LIST_REFS_SNAPSHOT_CACHE_TTL : Duration.zero),
+    },
+  );
+  const listRefsRefreshSnapshotCache = yield* Cache.makeWith(
+    (gitCommonDir: string) =>
+      Effect.suspend(() => {
+        const epoch = bumpListRefsEpoch(gitCommonDir);
+        return Cache.get(
+          listRefsSnapshotCache,
+          new GitRefsSnapshotCacheKey({ gitCommonDir, epoch }),
         );
-      }
+      }),
+    {
+      capacity: LIST_REFS_SNAPSHOT_CACHE_CAPACITY,
+      timeToLive: (exit) => (Exit.isSuccess(exit) ? LIST_REFS_REFRESH_COALESCE_TTL : Duration.zero),
+    },
+  );
+  const resolveListRefsSnapshot = (gitCommonDir: string, refresh: boolean) => {
+    const currentEpoch = listRefsEpochByCommonDir.get(gitCommonDir);
+    if (refresh || currentEpoch === undefined) {
+      // The refresh cache owns the complete snapshot read, rather than only the
+      // epoch bump. Slow repositories therefore remain singleflight for the
+      // entire Git scan even when more refresh requests arrive after the
+      // coalescing TTL would otherwise have elapsed.
+      return Cache.get(listRefsRefreshSnapshotCache, gitCommonDir);
+    }
+    return Cache.get(
+      listRefsSnapshotCache,
+      new GitRefsSnapshotCacheKey({ gitCommonDir, epoch: currentEpoch }),
+    );
+  };
+  const invalidateListRefsSnapshot = Effect.fn("invalidateListRefsSnapshot")(function* (
+    cwd: string,
+  ) {
+    const repositoryPaths = yield* resolveRepositoryPaths(cwd);
+    if (repositoryPaths === null) return;
+    yield* Cache.invalidate(listRefsRefreshSnapshotCache, repositoryPaths.gitCommonDir);
+    bumpListRefsEpoch(repositoryPaths.gitCommonDir);
+  });
 
-      const defaultBranch =
-        defaultRef.exitCode === 0
-          ? defaultRef.stdout.trim().replace(/^refs\/remotes\/origin\//, "")
-          : null;
-
-      const worktreeMap = new Map<string, string>();
-      if (worktreeList.exitCode === 0) {
-        let currentPath: string | null = null;
-        for (const line of worktreeList.stdout.split("\n")) {
-          if (line.startsWith("worktree ")) {
-            const candidatePath = line.slice("worktree ".length);
-            const exists = yield* fileSystem.stat(candidatePath).pipe(
-              Effect.map(() => true),
-              Effect.orElseSucceed(() => false),
-            );
-            currentPath = exists ? candidatePath : null;
-          } else if (line.startsWith("branch refs/heads/") && currentPath) {
-            worktreeMap.set(line.slice("branch refs/heads/".length), currentPath);
-          } else if (line === "") {
-            currentPath = null;
-          }
-        }
+  const listRefs: GitVcsDriver.GitVcsDriver["Service"]["listRefs"] = Effect.fn("listRefs")(
+    function* (input) {
+      const repositoryPaths = yield* resolveRepositoryPaths(input.cwd).pipe(
+        Effect.catchTags({
+          GitCommandError: (error) =>
+            isMissingGitCwdError(error) ? Effect.succeed(null) : Effect.fail(error),
+        }),
+      );
+      if (repositoryPaths === null) {
+        return {
+          refs: [],
+          isRepo: false,
+          hasPrimaryRemote: false,
+          nextCursor: null,
+          totalCount: 0,
+        };
       }
 
-      const localBranches = Arr.filterMap(localBranchResult.stdout.split("\n"), (line) => {
-        const refName = parseBranchLine(line);
-        return refName === null
-          ? Result.failVoid
-          : Result.succeed({
-              name: refName.name,
-              current: refName.current,
-              isRemote: false,
-              isDefault: refName.name === defaultBranch,
-              worktreePath: worktreeMap.get(refName.name) ?? null,
-            });
-      }).toSorted((a, b) => {
-        const aPriority = a.current ? 0 : a.isDefault ? 1 : 2;
-        const bPriority = b.current ? 0 : b.isDefault ? 1 : 2;
-        if (aPriority !== bPriority) return aPriority - bPriority;
-
-        const aLastCommit = branchLastCommit.get(a.name) ?? 0;
-        const bLastCommit = branchLastCommit.get(b.name) ?? 0;
-        if (aLastCommit !== bLastCommit) return bLastCommit - aLastCommit;
-        return a.name.localeCompare(b.name);
-      });
-
-      const remoteBranches =
-        remoteBranchResult.exitCode === 0
-          ? Arr.filterMap(remoteBranchResult.stdout.split("\n"), (line) => {
-              const refName = parseBranchLine(line);
-              if (refName === null) {
-                return Result.failVoid;
-              }
-              const parsedRemoteRef = parseRemoteRefWithRemoteNames(refName.name, remoteNames);
-              const remoteBranch: {
-                name: string;
-                current: boolean;
-                isRemote: boolean;
-                remoteName?: string;
-                isDefault: boolean;
-                worktreePath: string | null;
-              } = {
-                name: refName.name,
-                current: false,
-                isRemote: true,
-                // origin/HEAD's target is the repo default even when no local
-                // copy of the default branch exists.
-                isDefault:
-                  defaultBranch !== null &&
-                  parsedRemoteRef?.remoteName === "origin" &&
-                  parsedRemoteRef.branchName === defaultBranch,
-                worktreePath: null,
-              };
-              if (parsedRemoteRef) {
-                remoteBranch.remoteName = parsedRemoteRef.remoteName;
-              }
-              return Result.succeed(remoteBranch);
-            }).toSorted((a, b) => {
-              const aLastCommit = branchLastCommit.get(a.name) ?? 0;
-              const bLastCommit = branchLastCommit.get(b.name) ?? 0;
-              if (aLastCommit !== bLastCommit) return bLastCommit - aLastCommit;
-              return a.name.localeCompare(b.name);
-            })
-          : [];
-
+      const snapshot = yield* resolveListRefsSnapshot(
+        repositoryPaths.gitCommonDir,
+        input.refresh === true,
+      );
+      const localBranches = snapshot.localBranches.map((ref) => ({
+        ...ref,
+        current:
+          repositoryPaths.worktreeRoot !== null &&
+          ref.worktreePath === repositoryPaths.worktreeRoot,
+      }));

cursorBotJul 28, 2026

Current branch never marked

Medium Severity

current is set only when ref.worktreePath equals cached worktreeRoot. If git worktree list fails or rev-parse --show-toplevel once fails, worktreeRoot stays null and the worktree map is empty, so no ref is marked current even though the repo and branches are valid.

Additional Locations (2)

Fix in Cursor Fix in Web

^{Reviewed by Cursor Bugbot for commit 8fb87fd77be389089c439e78bb82e25c66d843bc. Configure here.}

1	In file @apps/server/src/vcs/GitVcsDriverCore.ts around line 246:
2
3	`parseWorktreeBranchPaths` splits `git worktree list --porcelain` output on `\n`, but worktree paths can legally contain newline characters. A worktree whose path contains a newline is split into multiple pseudo-lines, causing `currentPath` to be overwritten or misparsed, and the branch is dropped from `worktreePaths`. The caller then incorrectly reports `worktreePath: null` for that checked-out branch. Git's porcelain format requires parsing NUL-delimited (`-z`) output to handle paths with embedded newlines. Consider invoking the command with `-z` and parsing NUL-delimited records instead of splitting on `\n`.

1	In file @apps/web/src/state/paginatedBranches.ts around line 31:
2
3	`shouldLoadNextBranchPageAfterScroll` never loads the next page during slow or smooth scrolling. The guard `scrollTop <= previousScrollTop + 1` treats any downward movement of 1px or less as "not scrolling down," so successive subpixel or 1px scroll events are all rejected — even when the user reaches the bottom, `fetchNextBranchPage` is never called. Because `scrollTop` is subpixel-precise on modern browsers/trackpads, this is a common case, not an edge case. The direction check should reject only non-increasing movement (`scrollTop <= previousScrollTop`), not deltas `<= 1`.

1	In file @apps/server/src/vcs/GitVcsDriverCore.ts around line 236:
2
3	`parseWorktreeBranchPaths` returns worktree paths without verifying they exist on disk. Git omits the `prunable` marker until its prune-expiry threshold elapses, so a worktree directory deleted manually still appears as a valid entry — the returned map points the branch at a nonexistent path. Downstream branch selection can then try to reuse that stale worktree instead of checking out the branch normally. The previous implementation explicitly `stat`ed each path, which dropped these entries. Consider re-statting each path before adding it to the map (or pruning stale worktrees first) so deleted directories are not treated as usable.

1	- onSuccess: invalidateRefs,
2	+ onSettled: invalidateRefs,

Fix Git ref refresh resource storms#4727

Reconnect refetch skips server refresh

Current branch never marked

Clear failure still rehydrates stale cache

Late refresh repersists stale refs

Failed mutations skip ref invalidation

Coalesced refresh ignores invalidation

Cross-worktree stale persisted refs

Ignored for-each-ref failures

Failed stacked actions skip ref invalidation

Refresh status skips ref invalidation

Ref invalidation misses list cwd

Pull leaves ref lists stale

Stale cached current branch

Stacked commits skip ref invalidation

Backoff cleared on failed fetch

Stale refs after refresh failure

Stale persisted refs after invalidation