Use default tree for new chats and show stash badges (#372)

- surface stash counts on git branches
- create shortcut chats from the default tree
- preserve worktree selection behavior in the branch picker

Author: BunsDev

apps/server/src/git/Layers/GitCore.test.ts

@@ -226,6 +226,30 @@ it.layer(TestLayer)("git integration", (it) => {
       }),
     );
 
+    it.effect("marks worktree branches that still have stashed changes", () =>
+      Effect.gen(function* () {
+        const tmp = yield* makeTmpDir();
+        const { initialBranch } = yield* initRepoWithCommit(tmp);
+        const worktree = yield* (yield* GitCore).createWorktree({
+          cwd: tmp,
+          branch: initialBranch,
+          newBranch: "feature/stashed-worktree",
+          path: null,
+        });
+
+        yield* writeTextFile(path.join(worktree.worktree.path, "README.md"), "stashed change\n");
+        yield* git(worktree.worktree.path, ["stash", "push", "-m", "save worktree state"]);
+
+        const result = yield* (yield* GitCore).listBranches({ cwd: tmp });
+        const stashedBranch = result.branches.find(
+          (branch) => branch.name === "feature/stashed-worktree",
+        );
+        expect(stashedBranch?.name).toBe("feature/stashed-worktree");
+        expect(stashedBranch?.worktreePath).toBe(fs.realpathSync(worktree.worktree.path));
+        expect(stashedBranch?.stashCount).toBe(1);
+      }),
+    );
+
     it.effect(
       "does not include detached HEAD pseudo-refs as branches",
       () =>

apps/server/src/git/Layers/GitCore.ts

@@ -230,6 +230,29 @@ function parseRemoteRefWithRemoteNames(
   return null;
 }
 
+function parseStashBranchName(subject: string): string | null {
+  const trimmed = subject.trim();
+  if (trimmed.length === 0) {
+    return null;
+  }
+
+  const match = /^(?:WIP on|On)\s+(.+?):\s/.exec(trimmed);
+  const branchName = match?.[1]?.trim() ?? "";
+  return branchName.length > 0 ? branchName : null;
+}
+
+function parseStashCounts(stdout: string): ReadonlyMap<string, number> {
+  const counts = new Map<string, number>();
+  for (const line of stdout.split("\n")) {
+    const branchName = parseStashBranchName(line);
+    if (!branchName) {
+      continue;
+    }
+    counts.set(branchName, (counts.get(branchName) ?? 0) + 1);
+  }
+  return counts;
+}
+
 function parseUpstreamRef(
   value: string,
 ): { upstreamRef: string; remoteName: string; upstreamBranch: string } | null {
@@ -1662,36 +1685,57 @@ export const makeGitCore = (options?: { executeOverride?: GitCoreShape["execute"
           ),
         );
 
-        const [defaultRef, worktreeList, remoteBranchResult, remoteNamesResult, branchLastCommit] =
-          yield* Effect.all(
-            [
-              executeGit(
-                "GitCore.listBranches.defaultRef",
-                input.cwd,
-                ["symbolic-ref", "refs/remotes/origin/HEAD"],
-                {
-                  timeoutMs: 5_000,
-                  allowNonZeroExit: true,
-                },
-              ),
-              executeGit(
-                "GitCore.listBranches.worktreeList",
-                input.cwd,
-                ["worktree", "list", "--porcelain"],
-                {
-                  timeoutMs: 5_000,
-                  allowNonZeroExit: true,
-                },
-              ),
-              remoteBranchResultEffect,
-              remoteNamesResultEffect,
-              branchRecencyPromise,
-            ],
-            { concurrency: "unbounded" },
-          );
+        const stashListResultEffect = executeGit("GitCore.listBranches.stashList", input.cwd, [
+          "stash",
+          "list",
+          "--format=%gs",
+        ]).pipe(
+          Effect.catch((error) =>
+            Effect.logWarning(
+              `GitCore.listBranches: stash lookup failed for ${input.cwd}: ${error.message}. Falling back to an empty stash list.`,
+            ).pipe(Effect.as({ code: 1, stdout: "", stderr: "" })),
+          ),
+        );
+
+        const [
+          defaultRef,
+          worktreeList,
+          remoteBranchResult,
+          remoteNamesResult,
+          stashListResult,
+          branchLastCommit,
+        ] = yield* Effect.all(
+          [
+            executeGit(
+              "GitCore.listBranches.defaultRef",
+              input.cwd,
+              ["symbolic-ref", "refs/remotes/origin/HEAD"],
+              {
+                timeoutMs: 5_000,
+                allowNonZeroExit: true,
+              },
+            ),
+            executeGit(
+              "GitCore.listBranches.worktreeList",
+              input.cwd,
+              ["worktree", "list", "--porcelain"],
+              {
+                timeoutMs: 5_000,
+                allowNonZeroExit: true,
+              },
+            ),
+            remoteBranchResultEffect,
+            remoteNamesResultEffect,
+            stashListResultEffect,
+            branchRecencyPromise,
+          ],
+          { concurrency: "unbounded" },
+        );
 
         const remoteNames =
           remoteNamesResult.code === 0 ? parseRemoteNames(remoteNamesResult.stdout) : [];
+        const stashCounts =
+          stashListResult.code === 0 ? parseStashCounts(stashListResult.stdout) : new Map();
         if (remoteBranchResult.code !== 0 && remoteBranchResult.stderr.trim().length > 0) {
           yield* Effect.logWarning(
             `GitCore.listBranches: remote branch lookup returned code ${remoteBranchResult.code} for ${input.cwd}: ${remoteBranchResult.stderr.trim()}. Falling back to an empty remote branch list.`,
@@ -1702,6 +1746,11 @@ export const makeGitCore = (options?: { executeOverride?: GitCoreShape["execute"
             `GitCore.listBranches: remote name lookup returned code ${remoteNamesResult.code} for ${input.cwd}: ${remoteNamesResult.stderr.trim()}. Falling back to an empty remote name list.`,
           );
         }
+        if (stashListResult.code !== 0 && stashListResult.stderr.trim().length > 0) {
+          yield* Effect.logWarning(
+            `GitCore.listBranches: stash lookup returned code ${stashListResult.code} for ${input.cwd}: ${stashListResult.stderr.trim()}. Falling back to an empty stash list.`,
+          );
+        }
 
         const defaultBranch =
           defaultRef.code === 0
@@ -1731,13 +1780,27 @@ export const makeGitCore = (options?: { executeOverride?: GitCoreShape["execute"
           .split("\n")
           .map(parseBranchLine)
           .filter((branch): branch is { name: string; current: boolean } => branch !== null)
-          .map((branch) => ({
-            name: branch.name,
-            current: branch.current,
-            isRemote: false,
-            isDefault: branch.name === defaultBranch,
-            worktreePath: worktreeMap.get(branch.name) ?? null,
-          }))
+          .map((branch) => {
+            const localBranch: {
+              name: string;
+              current: boolean;
+              isRemote: boolean;
+              isDefault: boolean;
+              worktreePath: string | null;
+              stashCount?: number;
+            } = {
+              name: branch.name,
+              current: branch.current,
+              isRemote: false,
+              isDefault: branch.name === defaultBranch,
+              worktreePath: worktreeMap.get(branch.name) ?? null,
+            };
+            const stashCount = stashCounts.get(branch.name);
+            if (stashCount !== undefined) {
+              localBranch.stashCount = stashCount;
+            }
+            return localBranch;
+          })
           .toSorted((a, b) => {
             const aPriority = a.current ? 0 : a.isDefault ? 1 : 2;
             const bPriority = b.current ? 0 : b.isDefault ? 1 : 2;

apps/web/src/components/BranchToolbar.logic.test.ts

@@ -1,9 +1,11 @@
 import type { GitBranch } from "@okcode/contracts";
 import { describe, expect, it } from "vitest";
 import {
+  buildBranchMetadataBadges,
   dedupeRemoteBranchesWithLocalMatches,
   deriveLocalBranchNameFromRemoteRef,
   filterSelectableBranches,
+  formatBranchStashBadgeLabel,
   resolveBranchSelectionTarget,
   resolveDraftEnvModeAfterBranchChange,
   resolveBranchToolbarValue,
@@ -133,6 +135,50 @@ describe("filterSelectableBranches", () => {
   });
 });
 
+describe("formatBranchStashBadgeLabel", () => {
+  it("returns null when a branch has no stashes", () => {
+    expect(formatBranchStashBadgeLabel(undefined)).toBeNull();
+    expect(formatBranchStashBadgeLabel(0)).toBeNull();
+  });
+
+  it("formats stash badges compactly", () => {
+    expect(formatBranchStashBadgeLabel(1)).toBe("stash");
+    expect(formatBranchStashBadgeLabel(3)).toBe("stash 3");
+  });
+});
+
+describe("buildBranchMetadataBadges", () => {
+  it("includes stash badges alongside worktree metadata", () => {
+    expect(
+      buildBranchMetadataBadges({
+        activeProjectCwd: "/repo/project",
+        branch: {
+          current: false,
+          isDefault: false,
+          isRemote: false,
+          stashCount: 2,
+          worktreePath: "/repo/worktrees/feature-a",
+        },
+      }),
+    ).toEqual(["worktree", "stash 2"]);
+  });
+
+  it("does not treat the root checkout as a secondary worktree", () => {
+    expect(
+      buildBranchMetadataBadges({
+        activeProjectCwd: "/repo/project",
+        branch: {
+          current: true,
+          isDefault: true,
+          isRemote: false,
+          stashCount: 1,
+          worktreePath: "/repo/project",
+        },
+      }),
+    ).toEqual(["current", "default", "stash"]);
+  });
+});
+
 describe("dedupeRemoteBranchesWithLocalMatches", () => {
   it("hides remote refs when the matching local branch exists", () => {
     const input: GitBranch[] = [

apps/web/src/components/BranchToolbar.logic.ts

@@ -77,6 +77,41 @@ export function filterSelectableBranches(
   return branches.filter((branch) => !branch.isRemote);
 }
 
+export function formatBranchStashBadgeLabel(stashCount: number | undefined): string | null {
+  if (!stashCount || stashCount < 1) {
+    return null;
+  }
+  return stashCount === 1 ? "stash" : `stash ${stashCount}`;
+}
+
+export function buildBranchMetadataBadges(input: {
+  activeProjectCwd: string;
+  branch: Pick<GitBranch, "current" | "isDefault" | "isRemote" | "stashCount" | "worktreePath">;
+}): ReadonlyArray<string> {
+  const badges: string[] = [];
+  const hasSecondaryWorktree =
+    input.branch.worktreePath !== null && input.branch.worktreePath !== input.activeProjectCwd;
+
+  if (input.branch.current) {
+    badges.push("current");
+  }
+  if (hasSecondaryWorktree) {
+    badges.push("worktree");
+  }
+  if (input.branch.isRemote) {
+    badges.push("remote");
+  }
+  if (input.branch.isDefault) {
+    badges.push("default");
+  }
+  const stashBadge = formatBranchStashBadgeLabel(input.branch.stashCount);
+  if (stashBadge) {
+    badges.push(stashBadge);
+  }
+
+  return badges;
+}
+
 export function dedupeRemoteBranchesWithLocalMatches(
   branches: ReadonlyArray<GitBranch>,
   options?: {