Git integration: branch picker + worktrees#3

@@ -416,10 +421,37 @@ export default function ChatView() {
 
   const onSend = async (e: FormEvent) => {
     e.preventDefault();
-    if (!api || !activeThread || isSending || isConnecting) return;
+    if (!api || !activeThread || !activeProject || isSending || isConnecting)
+      return;
     const trimmed = prompt.trim();
     if (!trimmed) return;
 

@@ -0,0 +1,293 @@
+import type { GitBranch } from "@t3tools/contracts";
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+import { useEffect, useMemo, useRef, useState } from "react";
+
+import { readNativeApi } from "../session-logic";
+import { useStore } from "../store";
+
+interface BranchToolbarProps {
+  envMode: "local" | "worktree";
+  onEnvModeChange: (mode: "local" | "worktree") => void;
+  envLocked: boolean;
+}
+
+export default function BranchToolbar({ envMode, onEnvModeChange, envLocked }: BranchToolbarProps) {
+  const { state, dispatch } = useStore();
+  const api = useMemo(() => readNativeApi(), []);
+  const queryClient = useQueryClient();
+
+  const [isBranchMenuOpen, setIsBranchMenuOpen] = useState(false);
+  const [isCreatingBranch, setIsCreatingBranch] = useState(false);
+  const [newBranchName, setNewBranchName] = useState("");
+  const branchMenuRef = useRef<HTMLDivElement>(null);
+
+  const activeThread = state.threads.find((thread) => thread.id === state.activeThreadId);
+  const activeProject = state.projects.find((project) => project.id === activeThread?.projectId);
+  const activeThreadId = activeThread?.id;
+  const activeThreadBranch = activeThread?.branch ?? null;
+  const activeWorktreePath = activeThread?.worktreePath ?? null;
+  const branchCwd = activeWorktreePath ?? activeProject?.cwd;
+
+  // ── Queries ───────────────────────────────────────────────────────────
+
+  const branchesQuery = useQuery({
+    queryKey: ["git", "branches", branchCwd],
+    queryFn: () => api!.git.listBranches({ cwd: branchCwd! }),
+    enabled: !!api && !!branchCwd,
+  });
+
+  const branches = branchesQuery.data?.branches ?? [];
+  const isRepo = branchesQuery.data?.isRepo ?? false;
+
+  // ── Mutations ─────────────────────────────────────────────────────────
+
+  const checkoutMutation = useMutation({
+    mutationFn: (branch: string) => api!.git.checkout({ cwd: branchCwd!, branch }),
+    onSuccess: () => queryClient.invalidateQueries({ queryKey: ["git", "branches", branchCwd] }),
+    onError: (error) =>
+      setThreadError(error instanceof Error ? error.message : "Failed to checkout branch."),
+  });
+
+  const createBranchMutation = useMutation({
+    mutationFn: (branch: string) =>
+      api!.git
+        .createBranch({ cwd: branchCwd!, branch })
+        .then(() => api!.git.checkout({ cwd: branchCwd!, branch })),
+    onSuccess: () => queryClient.invalidateQueries({ queryKey: ["git", "branches", branchCwd] }),
+    onError: (error) =>
+      setThreadError(error instanceof Error ? error.message : "Failed to create branch."),
+  });
+
+  const initMutation = useMutation({
+    mutationFn: () => api!.git.init({ cwd: branchCwd! }),
+    onSuccess: () => {
+      setThreadError(null);
+      queryClient.invalidateQueries({ queryKey: ["git", "branches", branchCwd] });
+    },
+    onError: (error) =>
+      setThreadError(error instanceof Error ? error.message : "Failed to initialize git repo."),
+  });
+
+  // ── Effects ───────────────────────────────────────────────────────────
+
+  // Keep thread branch synced to git current branch for local threads.
+  const queryBranches = branchesQuery.data?.branches;
+  useEffect(() => {
+    if (!activeThreadId || activeWorktreePath) return;

@@ -0,0 +1,195 @@
+import { spawn } from "node:child_process";
+import os from "node:os";
+import path from "node:path";
+
+import type {
+  GitCheckoutInput,
+  GitCreateBranchInput,
+  GitCreateWorktreeInput,
+  GitCreateWorktreeResult,
+  GitInitInput,
+  GitListBranchesInput,
+  GitListBranchesResult,
+  GitRemoveWorktreeInput,
+  TerminalCommandInput,
+  TerminalCommandResult,
+} from "@t3tools/contracts";
+
+function escapeSingleQuotes(value: string): string {
+  return value.replace(/'/g, "'\\''");
+}
+
+export async function runTerminalCommand(
+  input: TerminalCommandInput,
+): Promise<TerminalCommandResult> {
+  const shellPath =
+    process.platform === "win32"
+      ? (process.env.ComSpec ?? "cmd.exe")
+      : (process.env.SHELL ?? "/bin/sh");
+
+  const args =
+    process.platform === "win32" ? ["/d", "/s", "/c", input.command] : ["-lc", input.command];
+
+  return new Promise((resolve, reject) => {
+    const child = spawn(shellPath, args, {
+      cwd: input.cwd,
+      env: process.env,
+      stdio: ["ignore", "pipe", "pipe"],
+    });
+
+    let stdout = "";
+    let stderr = "";
+    let timedOut = false;
+
+    const timeout = setTimeout(() => {
+      timedOut = true;
+      child.kill("SIGTERM");
+      setTimeout(() => {
+        if (!child.killed) {
+          child.kill("SIGKILL");
+        }
+      }, 1_000).unref();
+    }, input.timeoutMs ?? 30_000);
+
+    child.stdout?.on("data", (chunk: Buffer) => {
+      stdout += chunk.toString();
+    });
+
+    child.stderr?.on("data", (chunk: Buffer) => {
+      stderr += chunk.toString();
+    });
+
+    child.on("error", (error) => {
+      clearTimeout(timeout);
+      reject(error);
+    });
+
+    child.on("close", (code, signal) => {
+      clearTimeout(timeout);
+      resolve({
+        stdout,
+        stderr,
+        code: code ?? null,
+        signal: signal ?? null,
+        timedOut,
+      });
+    });
+  });
+}
+
+export async function listGitBranches(input: GitListBranchesInput): Promise<GitListBranchesResult> {
+  const result = await runTerminalCommand({
+    command: "git branch --no-color",
+    cwd: input.cwd,
+    timeoutMs: 10_000,
+  });
+
+  if (result.code !== 0) {
+    const stderr = result.stderr.trim();
+    if (stderr.includes("not a git repository")) {
+      return { branches: [], isRepo: false };
+    }
+    throw new Error(stderr || "git branch failed");
+  }
+
+  // Resolve the real default branch from the remote
+  const defaultRef = await runTerminalCommand({
+    command: "git symbolic-ref refs/remotes/origin/HEAD",
+    cwd: input.cwd,
+    timeoutMs: 5_000,
+  });
+  const defaultBranch =
+    defaultRef.code === 0 ? defaultRef.stdout.trim().replace(/^refs\/remotes\/origin\//, "") : null;
+
+  const branches = result.stdout
+    .split("\n")
+    .map((line) => line.trim())
+    .filter((line) => line.length > 0)
+    .map((line) => ({
+      name: line.replace(/^[*+]\s+/, ""),
+      current: line.startsWith("* "),
+      isDefault: line.replace(/^[*+]\s+/, "") === defaultBranch,
+    }))
+    .toSorted((a, b) => {
+      if (a.current !== b.current) return a.current ? -1 : 1;
+      if (a.isDefault !== b.isDefault) return a.isDefault ? -1 : 1;
+      return a.name.localeCompare(b.name);
+    });
+
+  return { branches, isRepo: true };
+}
+
+export async function createGitWorktree(
+  input: GitCreateWorktreeInput,
+): Promise<GitCreateWorktreeResult> {
+  const sanitizedBranch = input.newBranch.replace(/\//g, "-");
+  const repoName = path.basename(input.cwd);
+  const worktreePath =
+    input.path ?? path.join(os.homedir(), ".t3", "worktrees", repoName, sanitizedBranch);
+
+  // Create a new branch from the base branch in a new worktree
+  const result = await runTerminalCommand({
+    command: `git worktree add -b '${escapeSingleQuotes(input.newBranch)}' '${escapeSingleQuotes(worktreePath)}' '${escapeSingleQuotes(input.branch)}'`,
+    cwd: input.cwd,
+    timeoutMs: 30_000,
+  });
+
+  if (result.code !== 0) {
+    throw new Error(result.stderr.trim() || "git worktree add failed");
+  }
+
+  return {
+    worktree: {
+      path: worktreePath,
+      branch: input.newBranch,
+    },
+  };
+}
+
+export async function removeGitWorktree(input: GitRemoveWorktreeInput): Promise<void> {
+  const result = await runTerminalCommand({
+    command: `git worktree remove '${escapeSingleQuotes(input.path)}'`,

@@ -0,0 +1,129 @@
+import path from "node:path";
+
+import type {
+  GitCheckoutInput,
+  GitCreateBranchInput,
+  GitCreateWorktreeInput,
+  GitCreateWorktreeResult,
+  GitInitInput,
+  GitListBranchesInput,
+  GitListBranchesResult,
+  GitRemoveWorktreeInput,
+} from "@acme/contracts";
+import { runTerminalCommand } from "./terminal";
+
+export async function listGitBranches(input: GitListBranchesInput): Promise<GitListBranchesResult> {
+  const result = await runTerminalCommand({
+    command: "git branch --no-color",
+    cwd: input.cwd,
+    timeoutMs: 10_000,
+  });
+
+  if (result.code !== 0) {
+    const stderr = result.stderr.trim();
+    if (stderr.includes("not a git repository")) {
+      return { branches: [], isRepo: false };
+    }
+    throw new Error(stderr || "git branch failed");
+  }
+
+  // Resolve the real default branch from the remote
+  const defaultRef = await runTerminalCommand({
+    command: "git symbolic-ref refs/remotes/origin/HEAD",
+    cwd: input.cwd,
+    timeoutMs: 5_000,
+  });
+  const defaultBranch =
+    defaultRef.code === 0 ? defaultRef.stdout.trim().replace(/^refs\/remotes\/origin\//, "") : null;
+
+  const branches = result.stdout
+    .split("\n")
+    .map((line) => line.trim())
+    .filter((line) => line.length > 0)
+    .map((line) => ({
+      name: line.replace(/^[*+]\s+/, ""),
+      current: line.startsWith("* "),

@@ -154,7 +159,7 @@ export default function ChatView() {
     try {
       const session = await api.providers.startSession({
         provider: "codex",
-        cwd: activeProject.cwd || undefined,
+        cwd: activeThread.worktreePath ?? activeProject.cwd,

@@ -0,0 +1,60 @@
+import { TerminalCommandInput, TerminalCommandResult } from "@acme/contracts";
+import { spawn } from "node:child_process";
+
+export async function runTerminalCommand(
+  input: TerminalCommandInput,
+): Promise<TerminalCommandResult> {
+  const shellPath =
+    process.platform === "win32"
+      ? (process.env.ComSpec ?? "cmd.exe")
+      : (process.env.SHELL ?? "/bin/sh");
+
+  const args =
+    process.platform === "win32" ? ["/d", "/s", "/c", input.command] : ["-lc", input.command];
+
+  return new Promise((resolve, reject) => {
+    const child = spawn(shellPath, args, {
+      cwd: input.cwd,
+      env: process.env,
+      stdio: ["ignore", "pipe", "pipe"],
+    });
+
+    let stdout = "";
+    let stderr = "";
+    let timedOut = false;
+
+    const timeout = setTimeout(() => {
+      timedOut = true;
+      child.kill("SIGTERM");
+      setTimeout(() => {
+        if (!child.killed) {
+          child.kill("SIGKILL");
+        }
+      }, 1_000).unref();
+    }, input.timeoutMs ?? 30_000);
+
+    child.stdout?.on("data", (chunk: Buffer) => {
+      stdout += chunk.toString();

@@ -18,9 +18,9 @@
       "outputs": ["dist/**", "dist-electron/**"]
     },
     "dev": {
-      "dependsOn": ["@t3tools/contracts#build"],
+      "dependsOn": ["^dev"],
       "cache": false,
-      "persistent": true
+      "persistent": false
     },

@@ -18,11 +18,10 @@
   },
   "devDependencies": {
     "@types/node": "^22.10.2",
-    "concurrently": "^9.1.2",
     "electronmon": "^2.0.2",
-    "tsup": "^8.3.5",
+    "tsdown": "^0.20.3",
     "typescript": "^5.7.3",
-    "vitest": "^3.0.0",
+    "vitest": "^4.0.0",

@@ -0,0 +1,99 @@
+# Git Flows Integration Tests
+
+## Overview
+
+Real integration tests that run actual git commands against temporary repos. No mocking.
+
+## Step 1: Extract git functions into `apps/desktop/src/git.ts`
+
+The git functions (`listGitBranches`, `createGitWorktree`, `removeGitWorktree`, `createGitBranch`, `checkoutGitBranch`, `initGitRepo`) and their helper `runTerminalCommand` are currently private in `main.ts`. Extract them into a new `apps/desktop/src/git.ts` module with named exports.
+
+`main.ts` will import and re-use them — no behavior change, just moving code.
+
+**Files modified:**
+
+- `apps/desktop/src/git.ts` — new file with all git functions exported
+- `apps/desktop/src/main.ts` — import from `./git` instead of defining inline
+
+## Step 2: Create `apps/desktop/src/git.test.ts`
+
+Integration tests using real temp git repos. Each test group creates a fresh temp directory with `git init`, makes commits, creates branches as needed, and cleans up after.
+
+### Setup/teardown pattern
+
+```ts
+import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import {
+  listGitBranches,
+  createGitBranch,
+  checkoutGitBranch,
+  createGitWorktree,
+  removeGitWorktree,
+  initGitRepo,
+} from "./git";
+
+// Helper: run a raw git command in a dir (for test setup, not under test)
+// Helper: create an initial commit (git needs at least one commit for branches)
+```
+
+### Test groups
+
+**1. initGitRepo**
+
+- Creates a valid git repo in a temp dir
+- listGitBranches reports `isRepo: true` after init
+
+**2. listGitBranches**
+
+- Returns `isRepo: false` for non-git directory
+- Returns the current branch with `current: true`
+- Sorts current branch first
+- Lists multiple branches after creating them
+- `isDefault` is false when no remote (no origin/HEAD)
+
+**3. checkoutGitBranch**
+
+- Checks out an existing branch (current flag moves)
+- Throws when branch doesn't exist
+- Throws when checkout would overwrite uncommitted changes (dirty working tree)
+
+**4. createGitBranch**
+
+- Creates a new branch (appears in listGitBranches)
+- Throws when branch already exists
+
+**5. createGitWorktree + removeGitWorktree**
+
+- Creates a worktree directory at the expected path
+- Worktree has the correct branch checked out
+- Throws when branch is already checked out in another worktree
+- removeGitWorktree cleans up the worktree
+
+**6. Full flow: local branch checkout**
+
+- init → commit → create branch → checkout → verify current
+
+**7. Full flow: worktree creation from selected branch**
+
+- init → commit → create branch → create worktree → verify worktree dir exists and has correct branch
+
+**8. Full flow: thread switching simulation**
+
+- init → commit → create branch-a, branch-b → checkout a → checkout b → checkout a → verify current matches
+
+**9. Full flow: checkout conflict**
+
+- init → commit → create branch → modify file (unstaged) → checkout other branch → expect error
+
+## Verification
+
+```bash
+# Run the git integration tests
+cd apps/desktop && bun run test
+
+# Or just the git test file
+npx vitest run apps/desktop/src/git.test.ts
+```

@@ -0,0 +1,11 @@
+{
+  "$schema": "https://turbo.build/schema.json",
+  "extends": ["//"],
+  "tasks": {
+    "start": {
+      "dependsOn": ["build"],
+      "cache": false,
+      "persistent": true,
+    },
+  },

@@ -250,6 +289,95 @@ async function runTerminalCommand(
   });
 }
 
+async function listGitBranches(
+  input: GitListBranchesInput,
+): Promise<GitListBranchesResult> {
+  const result = await runTerminalCommand({
+    command: "git branch --no-color",
+    cwd: input.cwd,
+    timeoutMs: 10_000,
+  });
+
+  if (result.code !== 0) {
+    const stderr = result.stderr.trim();
+    if (stderr.includes("not a git repository")) {
+      return { branches: [], isRepo: false };
+    }
+    throw new Error(stderr || "git branch failed");
+  }
+
+  const defaultBranches = new Set(["main", "master"]);
+
+  const branches = result.stdout
+    .split("\n")
+    .map((line) => line.trim())
+    .filter((line) => line.length > 0)
+    .map((line) => ({
+      name: line.replace(/^[*+]\s+/, ""),
+      current: line.startsWith("* "),
+    }))
+    .sort((a, b) => {
+      if (a.current !== b.current) return a.current ? -1 : 1;
+      const aDefault = defaultBranches.has(a.name);
+      const bDefault = defaultBranches.has(b.name);
+      if (aDefault !== bDefault) return aDefault ? -1 : 1;
+      return a.name.localeCompare(b.name);
+    });
+
+  return { branches, isRepo: true };
+}
+
+async function createGitWorktree(
+  input: GitCreateWorktreeInput,
+): Promise<GitCreateWorktreeResult> {
+  const sanitizedBranch = input.branch.replace(/\//g, "-");

@@ -0,0 +1,212 @@
+import { spawn } from "node:child_process";
+import os from "node:os";
+import path from "node:path";
+
+import type {
+  GitCheckoutInput,
+  GitCreateBranchInput,
+  GitCreateWorktreeInput,
+  GitCreateWorktreeResult,
+  GitInitInput,
+  GitListBranchesInput,
+  GitListBranchesResult,
+  GitRemoveWorktreeInput,
+  TerminalCommandInput,
+  TerminalCommandResult,
+} from "@t3tools/contracts";
+
+/** Spawn git directly with an argv array — no shell, no quoting needed. */
+function runGit(
+  args: string[],
+  cwd: string,
+  timeoutMs = 30_000,
+): Promise<TerminalCommandResult> {
+  return new Promise((resolve, reject) => {
+    const child = spawn("git", args, {
+      cwd,
+      env: process.env,
+      stdio: ["ignore", "pipe", "pipe"],
+    });
+
+    let stdout = "";
+    let stderr = "";
+    let timedOut = false;
+
+    const timeout = setTimeout(() => {
+      timedOut = true;
+      child.kill("SIGTERM");
+      setTimeout(() => {
+        if (!child.killed) child.kill("SIGKILL");
+      }, 1_000).unref();
+    }, timeoutMs);
+
+    child.stdout?.on("data", (chunk: Buffer) => {
+      stdout += chunk.toString();
+    });
+    child.stderr?.on("data", (chunk: Buffer) => {
+      stderr += chunk.toString();
+    });
+    child.on("error", (error) => {
+      clearTimeout(timeout);
+      reject(error);
+    });
+    child.on("close", (code, signal) => {
+      clearTimeout(timeout);
+      resolve({ stdout, stderr, code: code ?? null, signal: signal ?? null, timedOut });
+    });
+  });
+}
+
+export async function runTerminalCommand(
+  input: TerminalCommandInput,
+): Promise<TerminalCommandResult> {
+  const shellPath =
+    process.platform === "win32"
+      ? (process.env.ComSpec ?? "cmd.exe")
+      : (process.env.SHELL ?? "/bin/sh");
+
+  const args =
+    process.platform === "win32" ? ["/d", "/s", "/c", input.command] : ["-lc", input.command];
+
+  return new Promise((resolve, reject) => {
+    const child = spawn(shellPath, args, {
+      cwd: input.cwd,
+      env: process.env,
+      stdio: ["ignore", "pipe", "pipe"],
+    });
+
+    let stdout = "";
+    let stderr = "";
+    let timedOut = false;
+
+    const timeout = setTimeout(() => {
+      timedOut = true;
+      child.kill("SIGTERM");
+      setTimeout(() => {
+        if (!child.killed) {
+          child.kill("SIGKILL");
+        }
+      }, 1_000).unref();
+    }, input.timeoutMs ?? 30_000);
+
+    child.stdout?.on("data", (chunk: Buffer) => {
+      stdout += chunk.toString();
+    });
+
+    child.stderr?.on("data", (chunk: Buffer) => {
+      stderr += chunk.toString();
+    });
+
+    child.on("error", (error) => {
+      clearTimeout(timeout);
+      reject(error);
+    });
+
+    child.on("close", (code, signal) => {
+      clearTimeout(timeout);
+      resolve({
+        stdout,
+        stderr,
+        code: code ?? null,
+        signal: signal ?? null,
+        timedOut,
+      });
+    });
+  });
+}
+
+export async function listGitBranches(input: GitListBranchesInput): Promise<GitListBranchesResult> {
+  const result = await runGit(["branch", "--no-color"], input.cwd, 10_000);
+
+  if (result.code !== 0) {
+    const stderr = result.stderr.trim();
+    if (stderr.includes("not a git repository")) {
+      return { branches: [], isRepo: false };
+    }
+    throw new Error(stderr || "git branch failed");
+  }
+
+  // Resolve the real default branch from the remote
+  const defaultRef = await runGit(
+    ["symbolic-ref", "refs/remotes/origin/HEAD"],
+    input.cwd,
+    5_000,
+  );
+  const defaultBranch =
+    defaultRef.code === 0 ? defaultRef.stdout.trim().replace(/^refs\/remotes\/origin\//, "") : null;
+
+  const branches = result.stdout
+    .split("\n")
+    .map((line) => line.trim())
+    .filter((line) => line.length > 0)
+    .map((line) => ({
+      name: line.replace(/^[*+]\s+/, ""),
+      current: line.startsWith("* "),
+      isDefault: line.replace(/^[*+]\s+/, "") === defaultBranch,
+    }))
+    .toSorted((a, b) => {
+      if (a.current !== b.current) return a.current ? -1 : 1;
+      if (a.isDefault !== b.isDefault) return a.isDefault ? -1 : 1;
+      return a.name.localeCompare(b.name);
+    });
+
+  return { branches, isRepo: true };
+}
+
+export async function createGitWorktree(
+  input: GitCreateWorktreeInput,
+): Promise<GitCreateWorktreeResult> {
+  const sanitizedBranch = input.newBranch.replace(/\//g, "-");
+  const repoName = path.basename(input.cwd);
+  const worktreePath =
+    input.path ?? path.join(os.homedir(), ".t3", "worktrees", repoName, sanitizedBranch);
+
+  // Create a new branch from the base branch in a new worktree
+  const result = await runGit(
+    ["worktree", "add", "-b", input.newBranch, worktreePath, input.branch],
+    input.cwd,
+  );
+
+  if (result.code !== 0) {
+    throw new Error(result.stderr.trim() || "git worktree add failed");
+  }
+
+  return {
+    worktree: {
+      path: worktreePath,
+      branch: input.newBranch,
+    },
+  };
+}
+
+export async function removeGitWorktree(input: GitRemoveWorktreeInput): Promise<void> {
+  const result = await runGit(["worktree", "remove", input.path], input.cwd, 15_000);
+
+  if (result.code !== 0) {
+    throw new Error(result.stderr.trim() || "git worktree remove failed");
+  }
+}
+
+export async function createGitBranch(input: GitCreateBranchInput): Promise<void> {
+  const result = await runGit(["branch", input.branch], input.cwd, 10_000);

@@ -0,0 +1,195 @@
+import { spawn } from "node:child_process";
+import os from "node:os";
+import path from "node:path";
+
+import type {
+  GitCheckoutInput,
+  GitCreateBranchInput,
+  GitCreateWorktreeInput,
+  GitCreateWorktreeResult,
+  GitInitInput,
+  GitListBranchesInput,
+  GitListBranchesResult,
+  GitRemoveWorktreeInput,
+  TerminalCommandInput,
+  TerminalCommandResult,
+} from "@t3tools/contracts";
+
+function escapeSingleQuotes(value: string): string {
+  return value.replace(/'/g, "'\\''");
+}
+
+export async function runTerminalCommand(
+  input: TerminalCommandInput,
+): Promise<TerminalCommandResult> {
+  const shellPath =
+    process.platform === "win32"
+      ? (process.env.ComSpec ?? "cmd.exe")
+      : (process.env.SHELL ?? "/bin/sh");
+
+  const args =
+    process.platform === "win32" ? ["/d", "/s", "/c", input.command] : ["-lc", input.command];
+
+  return new Promise((resolve, reject) => {
+    const child = spawn(shellPath, args, {
+      cwd: input.cwd,
+      env: process.env,
+      stdio: ["ignore", "pipe", "pipe"],
+    });
+
+    let stdout = "";
+    let stderr = "";
+    let timedOut = false;
+
+    const timeout = setTimeout(() => {
+      timedOut = true;
+      child.kill("SIGTERM");
+      setTimeout(() => {
+        if (!child.killed) {
+          child.kill("SIGKILL");
+        }
+      }, 1_000).unref();
+    }, input.timeoutMs ?? 30_000);
+
+    child.stdout?.on("data", (chunk: Buffer) => {
+      stdout += chunk.toString();

@@ -0,0 +1,294 @@
+import { useQuery, useQueryClient } from "@tanstack/react-query";
+import { useEffect, useMemo, useRef, useState } from "react";
+
+import { readNativeApi } from "../session-logic";
+import { useStore } from "../store";
+import { listBranchesQuery } from "../hooks/useGitState";
+
+interface BranchToolbarProps {
+  envMode: "local" | "worktree";
+  onEnvModeChange: (mode: "local" | "worktree") => void;
+  envLocked: boolean;
+}
+
+export default function BranchToolbar({ envMode, onEnvModeChange, envLocked }: BranchToolbarProps) {
+  const { state, dispatch } = useStore();
+  const api = useMemo(() => readNativeApi(), []);
+  const queryClient = useQueryClient();
+
+  const [isBranchMenuOpen, setIsBranchMenuOpen] = useState(false);
+  const [isCreatingBranch, setIsCreatingBranch] = useState(false);
+  const [newBranchName, setNewBranchName] = useState("");
+  const branchMenuRef = useRef<HTMLDivElement>(null);
+
+  const activeThread = state.threads.find((t) => t.id === state.activeThreadId);
+  const activeProject = state.projects.find((p) => p.id === activeThread?.projectId);
+
+  const branchCwd = activeThread?.worktreePath ?? activeProject?.cwd;
+  const { data: branchData } = useQuery(listBranchesQuery(branchCwd));
+  const isRepo = branchData?.isRepo ?? false;
+  const branches = branchData?.branches ?? [];
+
+  // Keep thread branch in sync with git for local (non-worktree) threads
+  useEffect(() => {
+    if (!activeThread) return;
+    const current = branches.find((b) => b.current);
+    if (!current) return;
+    // Worktree threads have a fixed branch — don't override
+    if (activeThread.worktreePath) return;
+    // Already in sync
+    if (activeThread.branch === current.name) return;
+    dispatch({
+      type: "SET_THREAD_BRANCH",
+      threadId: activeThread.id,
+      branch: current.name,
+      worktreePath: activeThread.worktreePath,
+    });
+  }, [activeThread, branches, dispatch]);
+
+  useEffect(() => {
+    if (!isBranchMenuOpen) return;
+
+    const handleClickOutside = (event: MouseEvent) => {
+      if (!branchMenuRef.current) return;
+      if (event.target instanceof Node && !branchMenuRef.current.contains(event.target)) {
+        setIsBranchMenuOpen(false);
+      }
+    };
+
+    window.addEventListener("mousedown", handleClickOutside);
+    return () => {
+      window.removeEventListener("mousedown", handleClickOutside);
+    };
+  }, [isBranchMenuOpen]);
+
+  if (!isRepo || !activeThread) return null;
+
+  return (
+    <div className="mx-auto flex max-w-3xl items-center justify-between px-1 pt-2">
+      {/* Env mode (left) */}
+      <div className="flex items-center gap-2">
+        {envLocked ? (
+          <span className="inline-flex items-center gap-1.5 px-1 text-[12px] text-muted-foreground/40">
+            {activeThread.worktreePath ? "Worktree" : "Local"}
+          </span>
+        ) : (
+          <button
+            type="button"
+            className={`inline-flex items-center gap-1.5 rounded-lg px-2 py-1 text-[12px] transition-colors duration-150 ${
+              envMode === "worktree"
+                ? "bg-accent text-foreground/80"
+                : "text-muted-foreground/50 hover:bg-accent/50 hover:text-muted-foreground/70"
+            }`}
+            onClick={() => onEnvModeChange(envMode === "local" ? "worktree" : "local")}
+          >
+            {envMode === "worktree" ? "New worktree" : "Local"}
+          </button>
+        )}
+      </div>
+
+      {/* Branch picker (right) */}
+      {branches.length > 0 && (
+        <div className="relative" ref={branchMenuRef}>
+          <button
+            type="button"
+            className="inline-flex items-center gap-1.5 rounded-lg px-2 py-1 text-[12px] text-muted-foreground/50 transition-colors duration-150 hover:bg-accent/50 hover:text-muted-foreground/70"
+            onClick={() => setIsBranchMenuOpen((o) => !o)}
+          >
+            <svg
+              width="12"
+              height="12"
+              viewBox="0 0 16 16"
+              fill="currentColor"
+              className="opacity-60"
+              aria-hidden="true"
+            >
+              <path d="M9.5 3.25a2.25 2.25 0 1 1 3 2.122V6A2.5 2.5 0 0 1 10 8.5H6a1 1 0 0 0-1 1v1.128a2.251 2.251 0 1 1-1.5 0V5.372a2.25 2.25 0 1 1 1.5 0v1.836A2.493 2.493 0 0 1 6 7h4a1 1 0 0 0 1-1v-.628A2.25 2.25 0 0 1 9.5 3.25Z" />
+            </svg>
+            <span className="max-w-[200px] truncate font-mono">
+              {activeThread.branch
+                ? envMode === "worktree" && !envLocked
+                  ? `From ${activeThread.branch}`
+                  : activeThread.branch
+                : "select branch"}
+            </span>
+            <svg
+              width="10"
+              height="10"
+              viewBox="0 0 10 10"
+              fill="none"
+              className="opacity-40"
+              aria-hidden="true"
+            >
+              <path
+                d="M2.5 4L5 6.5L7.5 4"
+                stroke="currentColor"
+                strokeWidth="1.2"
+                strokeLinecap="round"
+                strokeLinejoin="round"
+              />
+            </svg>
+          </button>
+          {isBranchMenuOpen && (
+            <div className="absolute bottom-full right-0 z-20 mb-2 w-[280px] rounded-2xl border border-border bg-popover/95 p-2 shadow-[0_16px_40px_rgba(0,0,0,0.55)] backdrop-blur">
+              <p className="px-2 py-1 text-[10px] font-medium uppercase tracking-wider text-muted-foreground/50">
+                Branch
+              </p>
+              <div className="max-h-64 overflow-y-auto">
+                {branches.map((b) => {
+                  const isSelected = b.name === activeThread.branch;
+                  return (
+                    <button
+                      key={b.name}
+                      type="button"
+                      className={`mb-0.5 flex w-full items-center justify-between gap-2 rounded-xl px-2 py-1.5 text-left font-mono text-xs transition-colors duration-150 ${
+                        isSelected
+                          ? "bg-accent text-foreground"
+                          : "text-foreground/90 hover:bg-accent/50"
+                      }`}
+                      onClick={async () => {
+                        if (api && activeProject) {

@@ -0,0 +1,24 @@
+{
+  "$schema": "https://turbo.build/schema.json",
+  "extends": ["//"],
+  "tasks": {
+    "build": {
+      "dependsOn": ["^build"],
+      "outputs": ["dist-electron/**"],
+    },
+    "dev": {
+      "dependsOn": ["t3#build"],
+      "persistent": true,
+    },
+    "start": {
+      "dependsOn": ["build", "@t3tools/web#build", "t3#build"],
+      "cache": false,
+      "persistent": true,
+    },
+    "smoke-test": {
+      "dependsOn": ["build", "@t3tools/web#build", "t3#build"],
+      "cache": false,
+      "outputs": [],
+    },
+  },

@@ -250,6 +289,95 @@ async function runTerminalCommand(
   });
 }
 
+async function listGitBranches(
+  input: GitListBranchesInput,
+): Promise<GitListBranchesResult> {
+  const result = await runTerminalCommand({
+    command: "git branch --no-color",
+    cwd: input.cwd,
+    timeoutMs: 10_000,
+  });
+
+  if (result.code !== 0) {
+    const stderr = result.stderr.trim();
+    if (stderr.includes("not a git repository")) {
+      return { branches: [], isRepo: false };
+    }
+    throw new Error(stderr || "git branch failed");
+  }
+
+  const defaultBranches = new Set(["main", "master"]);
+
+  const branches = result.stdout
+    .split("\n")
+    .map((line) => line.trim())
+    .filter((line) => line.length > 0)
+    .map((line) => ({
+      name: line.replace(/^[*+]\s+/, ""),
+      current: line.startsWith("* "),
+    }))
+    .sort((a, b) => {
+      if (a.current !== b.current) return a.current ? -1 : 1;
+      const aDefault = defaultBranches.has(a.name);
+      const bDefault = defaultBranches.has(b.name);
+      if (aDefault !== bDefault) return aDefault ? -1 : 1;
+      return a.name.localeCompare(b.name);
+    });
+
+  return { branches, isRepo: true };
+}
+
+async function createGitWorktree(
+  input: GitCreateWorktreeInput,
+): Promise<GitCreateWorktreeResult> {
+  const sanitizedBranch = input.branch.replace(/\//g, "-");
+  const repoName = path.basename(input.cwd);
+  const worktreePath =
+    input.path ??
+    path.join(input.cwd, "..", `${repoName}-worktrees`, sanitizedBranch);
+
+  const result = await runTerminalCommand({
+    command: `git worktree add '${worktreePath.replace(/'/g, "'\\''")}' '${input.branch.replace(/'/g, "'\\''")}'`,
+    cwd: input.cwd,
+    timeoutMs: 30_000,
+  });
+
+  if (result.code !== 0) {
+    throw new Error(result.stderr.trim() || "git worktree add failed");
+  }
+
+  return {
+    worktree: {
+      path: worktreePath,
+      branch: input.branch,
+    },
+  };
+}
+
+async function removeGitWorktree(input: GitRemoveWorktreeInput): Promise<void> {
+  const result = await runTerminalCommand({
+    command: `git worktree remove '${input.path.replace(/'/g, "'\\''")}'`,

@@ -1,3 +1,13 @@
+import * as path from "node:path";
 import { defineConfig } from "vitest/config";
 
-export default defineConfig({});
+export default defineConfig({
+  resolve: {
+    alias: [
+      {
+        find: /^@t3tools\/contracts$/,
+        replacement: path.resolve(import.meta.dirname, "./packages/contracts/src/index.ts"),
+      },
+    ],
+  },
+});

@@ -0,0 +1,306 @@
+import type { GitBranch } from "@t3tools/contracts";
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+import { useEffect, useMemo, useRef, useState } from "react";
+
+import { readNativeApi } from "../session-logic";
+import { useStore } from "../store";
+
+interface BranchToolbarProps {
+  envMode: "local" | "worktree";
+  onEnvModeChange: (mode: "local" | "worktree") => void;
+  envLocked: boolean;
+}
+
+export default function BranchToolbar({ envMode, onEnvModeChange, envLocked }: BranchToolbarProps) {
+  const { state, dispatch } = useStore();
+  const api = useMemo(() => readNativeApi(), []);
+  const queryClient = useQueryClient();
+
+  const [isBranchMenuOpen, setIsBranchMenuOpen] = useState(false);
+  const [isCreatingBranch, setIsCreatingBranch] = useState(false);
+  const [newBranchName, setNewBranchName] = useState("");
+  const branchMenuRef = useRef<HTMLDivElement>(null);
+
+  const activeThread = state.threads.find((thread) => thread.id === state.activeThreadId);
+  const activeProject = state.projects.find((project) => project.id === activeThread?.projectId);
+  const activeThreadId = activeThread?.id;
+  const activeThreadBranch = activeThread?.branch ?? null;
+  const activeWorktreePath = activeThread?.worktreePath ?? null;
+  const branchCwd = activeWorktreePath ?? activeProject?.cwd;
+
+  // ── Queries ───────────────────────────────────────────────────────────
+
+  const branchesQuery = useQuery({
+    queryKey: ["git", "branches", branchCwd],
+    queryFn: () => api!.git.listBranches({ cwd: branchCwd! }),
+    enabled: !!api && !!branchCwd,
+  });
+
+  const branches = branchesQuery.data?.branches ?? [];
+  const isRepo = branchesQuery.data?.isRepo ?? false;
+
+  // ── Mutations ─────────────────────────────────────────────────────────
+
+  const checkoutMutation = useMutation({
+    mutationFn: (branch: string) => api!.git.checkout({ cwd: branchCwd!, branch }),
+    onSuccess: () => queryClient.invalidateQueries({ queryKey: ["git", "branches", branchCwd] }),
+    onError: (error) =>
+      setThreadError(error instanceof Error ? error.message : "Failed to checkout branch."),
+  });
+
+  const createBranchMutation = useMutation({
+    mutationFn: (branch: string) =>
+      api!.git
+        .createBranch({ cwd: branchCwd!, branch })
+        .then(() => api!.git.checkout({ cwd: branchCwd!, branch })),
+    onSuccess: () => queryClient.invalidateQueries({ queryKey: ["git", "branches", branchCwd] }),
+    onError: (error) =>
+      setThreadError(error instanceof Error ? error.message : "Failed to create branch."),
+  });

@@ -25,10 +25,10 @@
     "@tailwindcss/vite": "^4.0.0",
     "@types/react": "^19.0.0",
     "@types/react-dom": "^19.0.0",
-    "@vitejs/plugin-react": "^4.3.4",
+    "@vitejs/plugin-react": "^5.1.4",
     "babel-plugin-react-compiler": "^19.0.0-beta-e552027-20250112",
     "tailwindcss": "^4.0.0",
     "typescript": "^5.7.3",
-    "vite": "^6.0.5"
+    "vite": "^8.0.0-beta.12"

@@ -0,0 +1,195 @@
+import { spawn } from "node:child_process";
+import os from "node:os";
+import path from "node:path";
+
+import type {
+  GitCheckoutInput,
+  GitCreateBranchInput,
+  GitCreateWorktreeInput,
+  GitCreateWorktreeResult,
+  GitInitInput,
+  GitListBranchesInput,
+  GitListBranchesResult,
+  GitRemoveWorktreeInput,
+  TerminalCommandInput,
+  TerminalCommandResult,
+} from "@t3tools/contracts";
+
+function escapeSingleQuotes(value: string): string {
+  return value.replace(/'/g, "'\\''");
+}
+
+export async function runTerminalCommand(
+  input: TerminalCommandInput,
+): Promise<TerminalCommandResult> {
+  const shellPath =
+    process.platform === "win32"
+      ? (process.env.ComSpec ?? "cmd.exe")
+      : (process.env.SHELL ?? "/bin/sh");
+
+  const args =
+    process.platform === "win32" ? ["/d", "/s", "/c", input.command] : ["-lc", input.command];
+
+  return new Promise((resolve, reject) => {
+    const child = spawn(shellPath, args, {
+      cwd: input.cwd,
+      env: process.env,
+      stdio: ["ignore", "pipe", "pipe"],
+    });
+
+    let stdout = "";
+    let stderr = "";
+    let timedOut = false;
+
+    const timeout = setTimeout(() => {
+      timedOut = true;
+      child.kill("SIGTERM");
+      setTimeout(() => {
+        if (!child.killed) {
+          child.kill("SIGKILL");
+        }
+      }, 1_000).unref();
+    }, input.timeoutMs ?? 30_000);
+
+    child.stdout?.on("data", (chunk: Buffer) => {
+      stdout += chunk.toString();
+    });
+
+    child.stderr?.on("data", (chunk: Buffer) => {
+      stderr += chunk.toString();
+    });
+
+    child.on("error", (error) => {
+      clearTimeout(timeout);
+      reject(error);
+    });
+
+    child.on("close", (code, signal) => {
+      clearTimeout(timeout);
+      resolve({
+        stdout,
+        stderr,
+        code: code ?? null,
+        signal: signal ?? null,
+        timedOut,
+      });
+    });
+  });
+}
+
+export async function listGitBranches(input: GitListBranchesInput): Promise<GitListBranchesResult> {
+  const result = await runTerminalCommand({
+    command: "git branch --no-color",
+    cwd: input.cwd,
+    timeoutMs: 10_000,
+  });
+
+  if (result.code !== 0) {
+    const stderr = result.stderr.trim();
+    if (stderr.includes("not a git repository")) {
+      return { branches: [], isRepo: false };
+    }
+    throw new Error(stderr || "git branch failed");
+  }
+
+  // Resolve the real default branch from the remote
+  const defaultRef = await runTerminalCommand({
+    command: "git symbolic-ref refs/remotes/origin/HEAD",
+    cwd: input.cwd,
+    timeoutMs: 5_000,
+  });
+  const defaultBranch =
+    defaultRef.code === 0 ? defaultRef.stdout.trim().replace(/^refs\/remotes\/origin\//, "") : null;
+
+  const branches = result.stdout
+    .split("\n")
+    .map((line) => line.trim())
+    .filter((line) => line.length > 0)
+    .map((line) => ({
+      name: line.replace(/^[*+]\s+/, ""),
+      current: line.startsWith("* "),
+      isDefault: line.replace(/^[*+]\s+/, "") === defaultBranch,
+    }))
+    .toSorted((a, b) => {
+      if (a.current !== b.current) return a.current ? -1 : 1;
+      if (a.isDefault !== b.isDefault) return a.isDefault ? -1 : 1;
+      return a.name.localeCompare(b.name);
+    });
+
+  return { branches, isRepo: true };
+}
+
+export async function createGitWorktree(
+  input: GitCreateWorktreeInput,
+): Promise<GitCreateWorktreeResult> {
+  const sanitizedBranch = input.newBranch.replace(/\//g, "-");
+  const repoName = path.basename(input.cwd);
+  const worktreePath =
+    input.path ?? path.join(os.homedir(), ".t3", "worktrees", repoName, sanitizedBranch);
+
+  // Create a new branch from the base branch in a new worktree
+  const result = await runTerminalCommand({
+    command: `git worktree add -b '${escapeSingleQuotes(input.newBranch)}' '${escapeSingleQuotes(worktreePath)}' '${escapeSingleQuotes(input.branch)}'`,
+    cwd: input.cwd,
+    timeoutMs: 30_000,
+  });
+
+  if (result.code !== 0) {
+    throw new Error(result.stderr.trim() || "git worktree add failed");
+  }
+
+  return {
+    worktree: {
+      path: worktreePath,
+      branch: input.newBranch,
+    },
+  };
+}
+
+export async function removeGitWorktree(input: GitRemoveWorktreeInput): Promise<void> {
+  const result = await runTerminalCommand({
+    command: `git worktree remove '${escapeSingleQuotes(input.path)}'`,
+    cwd: input.cwd,
+    timeoutMs: 15_000,
+  });
+
+  if (result.code !== 0) {
+    throw new Error(result.stderr.trim() || "git worktree remove failed");
+  }
+}
+
+export async function createGitBranch(input: GitCreateBranchInput): Promise<void> {
+  const result = await runTerminalCommand({
+    command: `git branch '${escapeSingleQuotes(input.branch)}'`,
+    cwd: input.cwd,
+    timeoutMs: 10_000,
+  });
+
+  if (result.code !== 0) {
+    throw new Error(result.stderr.trim() || "git branch create failed");
+  }
+}
+
+export async function checkoutGitBranch(input: GitCheckoutInput): Promise<void> {
+  const result = await runTerminalCommand({
+    command: `git checkout '${escapeSingleQuotes(input.branch)}'`,
+    cwd: input.cwd,
+    timeoutMs: 10_000,
+  });
+
+  if (result.code !== 0) {
+    throw new Error(result.stderr.trim() || "git checkout failed");
+  }
+}

@@ -0,0 +1,9 @@
+{
+  "$schema": "https://turbo.build/schema.json",
+  "extends": ["//"],
+  "tasks": {
+    "dev": {
+      "persistent": true,
+    },
+  },

@@ -2,6 +2,8 @@ import tailwindcss from "@tailwindcss/vite";
 import react from "@vitejs/plugin-react";
 import { defineConfig } from "vite";
 
+const port = Number(process.env.PORT ?? 5173);

@@ -0,0 +1,293 @@
+import type { GitBranch } from "@t3tools/contracts";
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+import { useEffect, useMemo, useRef, useState } from "react";
+
+import { readNativeApi } from "../session-logic";
+import { useStore } from "../store";
+
+interface BranchToolbarProps {
+  envMode: "local" | "worktree";
+  onEnvModeChange: (mode: "local" | "worktree") => void;
+  envLocked: boolean;
+}
+
+export default function BranchToolbar({ envMode, onEnvModeChange, envLocked }: BranchToolbarProps) {
+  const { state, dispatch } = useStore();
+  const api = useMemo(() => readNativeApi(), []);
+  const queryClient = useQueryClient();
+
+  const [isBranchMenuOpen, setIsBranchMenuOpen] = useState(false);
+  const [isCreatingBranch, setIsCreatingBranch] = useState(false);
+  const [newBranchName, setNewBranchName] = useState("");
+  const branchMenuRef = useRef<HTMLDivElement>(null);
+
+  const activeThread = state.threads.find((thread) => thread.id === state.activeThreadId);
+  const activeProject = state.projects.find((project) => project.id === activeThread?.projectId);
+  const activeThreadId = activeThread?.id;
+  const activeThreadBranch = activeThread?.branch ?? null;
+  const activeWorktreePath = activeThread?.worktreePath ?? null;
+  const branchCwd = activeWorktreePath ?? activeProject?.cwd;
+
+  // ── Queries ───────────────────────────────────────────────────────────
+
+  const branchesQuery = useQuery({
+    queryKey: ["git", "branches", branchCwd],
+    queryFn: () => api!.git.listBranches({ cwd: branchCwd! }),
+    enabled: !!api && !!branchCwd,
+  });
+
+  const branches = branchesQuery.data?.branches ?? [];
+  const isRepo = branchesQuery.data?.isRepo ?? false;
+
+  // ── Mutations ─────────────────────────────────────────────────────────
+
+  const checkoutMutation = useMutation({
+    mutationFn: (branch: string) => api!.git.checkout({ cwd: branchCwd!, branch }),
+    onSuccess: () => queryClient.invalidateQueries({ queryKey: ["git", "branches", branchCwd] }),
+    onError: (error) =>
+      setThreadError(error instanceof Error ? error.message : "Failed to checkout branch."),
+  });
+
+  const createBranchMutation = useMutation({
+    mutationFn: (branch: string) =>
+      api!.git
+        .createBranch({ cwd: branchCwd!, branch })
+        .then(() => api!.git.checkout({ cwd: branchCwd!, branch })),
+    onSuccess: () => queryClient.invalidateQueries({ queryKey: ["git", "branches", branchCwd] }),
+    onError: (error) =>
+      setThreadError(error instanceof Error ? error.message : "Failed to create branch."),

@@ -0,0 +1,129 @@
+import path from "node:path";
+
+import type {
+  GitCheckoutInput,
+  GitCreateBranchInput,
+  GitCreateWorktreeInput,
+  GitCreateWorktreeResult,
+  GitInitInput,
+  GitListBranchesInput,
+  GitListBranchesResult,
+  GitRemoveWorktreeInput,
+} from "@acme/contracts";
+import { runTerminalCommand } from "./terminal";
+
+export async function listGitBranches(input: GitListBranchesInput): Promise<GitListBranchesResult> {
+  const result = await runTerminalCommand({
+    command: "git branch --no-color",
+    cwd: input.cwd,
+    timeoutMs: 10_000,
+  });
+
+  if (result.code !== 0) {
+    const stderr = result.stderr.trim();
+    if (stderr.includes("not a git repository")) {
+      return { branches: [], isRepo: false };
+    }
+    throw new Error(stderr || "git branch failed");
+  }
+
+  // Resolve the real default branch from the remote
+  const defaultRef = await runTerminalCommand({
+    command: "git symbolic-ref refs/remotes/origin/HEAD",
+    cwd: input.cwd,
+    timeoutMs: 5_000,
+  });
+  const defaultBranch =
+    defaultRef.code === 0 ? defaultRef.stdout.trim().replace(/^refs\/remotes\/origin\//, "") : null;
+
+  const branches = result.stdout
+    .split("\n")
+    .map((line) => line.trim())
+    .filter((line) => line.length > 0)
+    .map((line) => ({
+      name: line.replace(/^[*+]\s+/, ""),
+      current: line.startsWith("* "),

@@ -0,0 +1,312 @@
+import type { GitBranch } from "@t3tools/contracts";
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+
+import { readNativeApi } from "../session-logic";
+import { useStore } from "../store";
+
+interface BranchToolbarProps {
+  envMode: "local" | "worktree";
+  onEnvModeChange: (mode: "local" | "worktree") => void;
+  envLocked: boolean;
+}
+
+export default function BranchToolbar({
+  envMode,
+  onEnvModeChange,
+  envLocked,
+}: BranchToolbarProps) {
+  const { state, dispatch } = useStore();
+  const api = useMemo(() => readNativeApi(), []);
+
+  const [branches, setBranches] = useState<GitBranch[]>([]);
+  const [isRepo, setIsRepo] = useState(false);
+  const [isLoadingBranches, setIsLoadingBranches] = useState(false);
+  const [isBranchMenuOpen, setIsBranchMenuOpen] = useState(false);
+  const [isCreatingBranch, setIsCreatingBranch] = useState(false);
+  const [newBranchName, setNewBranchName] = useState("");
+  const [isInitializingRepo, setIsInitializingRepo] = useState(false);
+  const branchMenuRef = useRef<HTMLDivElement>(null);
+
+  const activeThread = state.threads.find((thread) => thread.id === state.activeThreadId);
+  const activeProject = state.projects.find((project) => project.id === activeThread?.projectId);
+  const branchCwd = activeThread?.worktreePath ?? activeProject?.cwd;
+
+  const loadBranches = useCallback(async () => {
+    if (!api || !branchCwd) return;
+    setIsLoadingBranches(true);
+    try {
+      const result = await api.git.listBranches({ cwd: branchCwd });
+      setIsRepo(result.isRepo);
+      setBranches(result.branches);
+    } catch (error) {
+      setIsRepo(false);
+      setBranches([]);
+      if (activeThread) {
+        dispatch({
+          type: "SET_ERROR",
+          threadId: activeThread.id,
+          error:
+            error instanceof Error ? error.message : "Failed to load git branches.",
+        });
+      }
+    } finally {
+      setIsLoadingBranches(false);
+    }
+  }, [activeThread, api, branchCwd, dispatch]);
+
+  useEffect(() => {
+    void loadBranches();
+  }, [loadBranches]);
+
+  // Keep thread branch synced to git current branch for local threads.
+  useEffect(() => {
+    if (!activeThread || activeThread.worktreePath) return;
+    const current = branches.find((branch) => branch.current);
+    if (!current) return;
+    if (current.name === activeThread.branch) return;
+    dispatch({
+      type: "SET_THREAD_BRANCH",
+      threadId: activeThread.id,
+      branch: current.name,
+      worktreePath: null,
+    });
+  }, [activeThread, branches, dispatch]);