perf(git): compute worktree ahead/behind via git status instead of rev-list

getWorktreeHealth spawned up to 3 git subprocesses per worktree (rev-parse
for the upstream name, log for last-commit date, and a conditional
rev-list to count ahead/behind). `git status --porcelain=v2 --branch`
reports the upstream name and its ahead/behind counts natively in one
call, cutting the common case down to 2 subprocesses (status + log) — the
rev-list fallback now only runs for the less common no-upstream+baseRef
case, where git's own status can't compute ahead/behind for us.

Motivated by a reproducible Windows-only E2E failure on this branch
(daily-workflow.spec.ts, stash-cherry-pick-workflow.spec.ts) that didn't
reproduce on main or other concurrent PRs at the same point in time: the
extra concurrent git.exe spawns this feature added on every workspace/
worktree-list load were tipping the odds of an existing, separately
tracked directory-deletion race (WORKSPACE_CLOSE waiting for in-flight git
ops, #162) specifically on Windows, where spawning git is markedly slower
than macOS/Linux. A prior attempt to fix this by slowing the poll interval
did not help, since TanStack Query fires the initial fetch immediately on
mount regardless of staleTime/refetchInterval — the actual burst this
targets happens right when worktrees load, not on the steady-state poll.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

Author: liam-russell

packages/git/src/health.ts

@@ -11,35 +11,49 @@ const DEFAULT_CONCURRENCY = 4;
  * otherwise — matching how `git status` reports ahead/behind when tracking
  * is configured, while still giving branches with no upstream a meaningful
  * comparison.
+ *
+ * Only spawns two git subprocesses per worktree in the common case (one
+ * `status --branch`, which reports the upstream name and its ahead/behind
+ * counts natively, plus one `log` for the last-commit date) rather than
+ * three (a separate `rev-parse` for the upstream name and a `rev-list` to
+ * count ahead/behind) — this runs once per worktree per sidebar refresh, so
+ * fewer subprocess spawns measurably reduces contention with other git
+ * commands firing at the same time, particularly on Windows where spawning
+ * `git` is markedly slower than on macOS/Linux (see remote.test.ts's timeout
+ * comments for the same observation elsewhere in this codebase). The
+ * `rev-list` fallback is only used for the less common no-upstream+baseRef
+ * case, where git's own status can't compute ahead/behind for us.
  */
 export async function getWorktreeHealth(
   worktreePath: string,
   baseRef?: string | null
 ): Promise<WorktreeHealth> {
   const git = gitForPath(worktreePath);
 
-  const [lastCommitRaw, upstream] = await Promise.all([
+  const [lastCommitRaw, branchStatusRaw] = await Promise.all([
     git.raw(['log', '-1', '--format=%aI']).catch(() => ''),
-    git
-      .raw(['rev-parse', '--abbrev-ref', '--symbolic-full-name', '@{u}'])
-      .then(r => r.trim())
-      .catch(() => null),
+    git.raw(['status', '--porcelain=v2', '--branch', '--untracked-files=no']).catch(() => ''),
   ]);
 
-  const compareRef = upstream ?? (baseRef || null);
+  const { upstream, ahead: statusAhead, behind: statusBehind } = parseBranchStatus(branchStatusRaw);
 
-  let ahead = 0;
-  let behind = 0;
-  if (compareRef) {
+  let compareRef = upstream;
+  let ahead = statusAhead;
+  let behind = statusBehind;
+
+  if (!upstream && baseRef) {
+    compareRef = baseRef;
     try {
       // `--left-right --count A...B` prints "<left-only> <right-only>" —
-      // left (compareRef) is what we're behind on, right (HEAD) is ahead.
-      const raw = await git.raw(['rev-list', '--left-right', '--count', `${compareRef}...HEAD`]);
+      // left (baseRef) is what we're behind on, right (HEAD) is ahead. Only
+      // needed here because there's no upstream for `git status` to compare
+      // HEAD against on its own.
+      const raw = await git.raw(['rev-list', '--left-right', '--count', `${baseRef}...HEAD`]);
       const [behindStr, aheadStr] = raw.trim().split(/\s+/);
       behind = parseInt(behindStr ?? '0', 10) || 0;
       ahead = parseInt(aheadStr ?? '0', 10) || 0;
     } catch {
-      // compareRef doesn't resolve (deleted branch, unrelated history, etc.)
+      // baseRef doesn't resolve (deleted branch, unrelated history, etc.)
       // — leave ahead/behind at 0 rather than failing the whole snapshot.
     }
   }
@@ -54,12 +68,36 @@ export async function getWorktreeHealth(
   };
 }
 
+/**
+ * Parses the `# branch.*` header lines from `git status --porcelain=v2
+ * --branch` — specifically `# branch.upstream <name>` and
+ * `# branch.ab +<ahead> -<behind>`, both omitted entirely when the branch
+ * has no upstream.
+ */
+function parseBranchStatus(raw: string): { upstream: string | null; ahead: number; behind: number } {
+  let upstream: string | null = null;
+  let ahead = 0;
+  let behind = 0;
+  for (const line of raw.split('\n')) {
+    if (line.startsWith('# branch.upstream ')) {
+      upstream = line.slice('# branch.upstream '.length).trim();
+    } else if (line.startsWith('# branch.ab ')) {
+      const match = /^# branch\.ab \+(\d+) -(\d+)/.exec(line);
+      if (match) {
+        ahead = parseInt(match[1]!, 10);
+        behind = parseInt(match[2]!, 10);
+      }
+    }
+  }
+  return { upstream, ahead, behind };
+}
+
 /**
  * Computes health for every worktree in `worktreePaths`, capping how many
- * run at once. Each worktree's health already fans out to a handful of git
- * subprocesses (log, rev-parse, rev-list) — running all worktrees fully in
- * parallel would spawn far more `git` processes at once than is useful,
- * especially in workspaces with a dozen+ worktrees.
+ * run at once. Each worktree's health already fans out to a couple of git
+ * subprocesses (status, log) — running all worktrees fully in parallel
+ * would spawn far more `git` processes at once than is useful, especially
+ * in workspaces with a dozen+ worktrees.
  *
  * Entries are only present for worktrees whose health was computed
  * successfully — a worktree removed mid-refresh is simply absent from the