diff --git a/electron.vite.config.ts b/electron.vite.config.ts
index 214d4da..9305b63 100644
--- a/electron.vite.config.ts
+++ b/electron.vite.config.ts
@@ -10,6 +10,11 @@ export default defineConfig({
       rollupOptions: {
         external: ['node-pty']
       }
+    },
+    server: {
+      watch: {
+        ignored: ['**/.konductor/**']
+      }
     }
   },
   preload: {
@@ -22,6 +27,11 @@ export default defineConfig({
       }
     },
     plugins: [react()],
+    server: {
+      watch: {
+        ignored: ['**/.konductor/**']
+      }
+    },
     define: {
       __APP_VERSION__: JSON.stringify(pkg.version)
     }
diff --git a/src/main/fileWatcher.ts b/src/main/fileWatcher.ts
index 53ff4d6..67408c2 100644
--- a/src/main/fileWatcher.ts
+++ b/src/main/fileWatcher.ts
@@ -86,7 +86,7 @@ export function createFileWatcher(
 
   // Watch for FS changes to trigger git status refresh
   watcher = watch(cwd, {
-    ignored: ['**/.git/**', '**/node_modules/**'],
+    ignored: ['**/.git/**', '**/node_modules/**', '**/.konductor/**'],
     persistent: true,
     ignoreInitial: true,
     awaitWriteFinish: {
diff --git a/src/main/index.ts b/src/main/index.ts
index 096105a..c5dd50b 100644
--- a/src/main/index.ts
+++ b/src/main/index.ts
@@ -29,7 +29,9 @@ import {
   getBranchDetails,
   deleteBranch,
   deleteRemoteBranch,
-  fetchPrune
+  fetchPrune,
+  getBranchFiles,
+  getBranchDiff
 } from './worktree'
 import { getGitHubRepo, listPullRequests, listIssues } from './github'
 
@@ -207,6 +209,27 @@ app.whenReady().then(() => {
     return shell.openExternal(url)
   })
 
+  ipcMain.handle(
+    'get-branch-files',
+    (_event, cwd: string, branch: string, worktreePath: string) => {
+      return getBranchFiles(cwd, branch, worktreePath)
+    }
+  )
+
+  ipcMain.handle(
+    'get-branch-diff',
+    (
+      _event,
+      cwd: string,
+      branch: string,
+      filePath: string,
+      source: 'committed' | 'uncommitted',
+      worktreePath: string
+    ) => {
+      return getBranchDiff(cwd, branch, filePath, source, worktreePath)
+    }
+  )
+
   ipcMain.handle('select-directory', async () => {
     if (!mainWindow) return null
     const result = await dialog.showOpenDialog(mainWindow, {
diff --git a/src/main/worktree.ts b/src/main/worktree.ts
index 3bcd229..814e9e8 100644
--- a/src/main/worktree.ts
+++ b/src/main/worktree.ts
@@ -1,6 +1,6 @@
 import { execFile } from 'child_process'
 import { join } from 'path'
-import { mkdir, rm } from 'fs/promises'
+import { mkdir } from 'fs/promises'
 
 function git(args: string[], cwd: string): Promise<string> {
   return new Promise((resolve, reject) => {
@@ -89,12 +89,24 @@ export async function createWorktree(
 }
 
 export async function removeWorktree(repoRoot: string, worktreePath: string): Promise<void> {
-  await rm(worktreePath, { recursive: true, force: true })
-
-  await new Promise<void>((resolve) => {
-    execFile('git', ['worktree', 'prune'], { cwd: repoRoot }, () => {
+  // Use git worktree remove first — it handles cleanup of .git references
+  await new Promise<void>((resolve, reject) => {
+    execFile('git', ['worktree', 'remove', '--force', worktreePath], { cwd: repoRoot }, (err) => {
+      if (err) {
+        reject(err)
+        return
+      }
       resolve()
     })
+  }).catch(async () => {
+    // Fallback: force-remove the directory (handles suid binaries like chrome-sandbox
+    // that Node's fs.rm can't delete) then prune the worktree list
+    await new Promise<void>((resolve) => {
+      execFile('rm', ['-rf', worktreePath], () => resolve())
+    })
+    await new Promise<void>((resolve) => {
+      execFile('git', ['worktree', 'prune'], { cwd: repoRoot }, () => resolve())
+    })
   })
 }
 
@@ -120,6 +132,14 @@ export function listBranches(cwd: string): Promise<string[]> {
   })
 }
 
+export type PrState = 'open' | 'merged' | 'closed' | 'none'
+
+export interface PrInfo {
+  state: PrState
+  number: number
+  url: string
+}
+
 export interface BranchDetail {
   name: string
   isHead: boolean
@@ -129,6 +149,77 @@ export interface BranchDetail {
   lastCommitRelative: string
   lastCommitSubject: string
   worktreePath: string
+  aheadCount: number
+  dirty: boolean
+  pr: PrInfo
+}
+
+function getAheadCount(cwd: string, branch: string, mainBranch: string): Promise<number> {
+  return new Promise((resolve) => {
+    execFile('git', ['rev-list', '--count', `${mainBranch}..${branch}`], { cwd }, (err, stdout) => {
+      if (err) {
+        resolve(-1)
+        return
+      }
+      resolve(parseInt(stdout.trim(), 10) || 0)
+    })
+  })
+}
+
+const NO_PR: PrInfo = { state: 'none', number: 0, url: '' }
+
+function getPrStatus(cwd: string, branch: string): Promise<PrInfo> {
+  return new Promise((resolve) => {
+    execFile(
+      'gh',
+      [
+        'pr',
+        'list',
+        '--head',
+        branch,
+        '--state',
+        'all',
+        '--json',
+        'state,number,url',
+        '--limit',
+        '1'
+      ],
+      { cwd },
+      (err, stdout) => {
+        if (err) {
+          resolve(NO_PR)
+          return
+        }
+        try {
+          const prs = JSON.parse(stdout.trim())
+          if (prs.length === 0) {
+            resolve(NO_PR)
+            return
+          }
+          const pr = prs[0]
+          resolve({
+            state: (pr.state as string).toLowerCase() as PrState,
+            number: pr.number,
+            url: pr.url
+          })
+        } catch {
+          resolve(NO_PR)
+        }
+      }
+    )
+  })
+}
+
+function isWorktreeDirty(worktreePath: string): Promise<boolean> {
+  return new Promise((resolve) => {
+    execFile('git', ['status', '--porcelain'], { cwd: worktreePath }, (err, stdout) => {
+      if (err) {
+        resolve(false)
+        return
+      }
+      resolve(stdout.trim().length > 0)
+    })
+  })
 }
 
 export function getBranchDetails(cwd: string): Promise<BranchDetail[]> {
@@ -161,24 +252,41 @@ export function getBranchDetails(cwd: string): Promise<BranchDetail[]> {
         }
 
         const wtByBranch = new Map(worktrees.map((w) => [w.branch, w.path]))
+        const mainBranch = 'origin/' + (worktrees.find((w) => w.isMain)?.branch ?? 'main')
 
-        const branches: BranchDetail[] = stdout
+        const parsed = stdout
           .trim()
           .split('\n')
           .filter((line) => line.length > 0)
-          .map((line) => {
-            const obj = JSON.parse(line)
+          .map((line) => JSON.parse(line))
+
+        const branches: BranchDetail[] = await Promise.all(
+          parsed.map(async (obj) => {
+            const name: string = obj.name
+            const worktreePath = wtByBranch.get(name) || ''
+            const isMain = name === mainBranch
+
+            const [aheadCount, dirty, pr] = await Promise.all([
+              isMain ? Promise.resolve(0) : getAheadCount(cwd, name, mainBranch),
+              worktreePath ? isWorktreeDirty(worktreePath) : Promise.resolve(false),
+              isMain ? Promise.resolve(NO_PR) : getPrStatus(cwd, name)
+            ])
+
             return {
-              name: obj.name,
+              name,
               isHead: obj.head === '*',
               upstream: obj.upstream || '',
               gone: obj.track.includes('gone'),
               lastCommitDate: obj.date || '',
               lastCommitRelative: obj.relative || '',
               lastCommitSubject: obj.subject || '',
-              worktreePath: wtByBranch.get(obj.name) || ''
+              worktreePath,
+              aheadCount,
+              dirty,
+              pr
             }
           })
+        )
 
         resolve(branches)
       }
@@ -186,6 +294,94 @@ export function getBranchDetails(cwd: string): Promise<BranchDetail[]> {
   })
 }
 
+export interface BranchFile {
+  path: string
+  status: 'A' | 'M' | 'D' | 'R' | 'U'
+  source: 'committed' | 'uncommitted'
+}
+
+/** List files changed on a branch (committed vs origin/main + uncommitted in worktree) */
+export async function getBranchFiles(
+  cwd: string,
+  branch: string,
+  worktreePath: string
+): Promise<BranchFile[]> {
+  const files: BranchFile[] = []
+
+  // Committed changes: branch vs origin/main
+  const committed = await new Promise<string>((resolve) => {
+    execFile('git', ['diff', '--name-status', 'origin/main...' + branch], { cwd }, (err, stdout) =>
+      resolve(err ? '' : stdout)
+    )
+  })
+
+  for (const line of committed.trim().split('\n')) {
+    if (!line) continue
+    const [statusRaw, ...pathParts] = line.split('\t')
+    const status = statusRaw.charAt(0) as BranchFile['status']
+    const path = pathParts[pathParts.length - 1] // handles renames (R\told\tnew)
+    if (path) files.push({ path, status, source: 'committed' })
+  }
+
+  // Uncommitted changes in the worktree
+  if (worktreePath) {
+    const uncommitted = await new Promise<string>((resolve) => {
+      execFile(
+        'git',
+        ['status', '--porcelain', '--no-renames'],
+        { cwd: worktreePath },
+        (err, stdout) => resolve(err ? '' : stdout)
+      )
+    })
+
+    for (const line of uncommitted.trim().split('\n')) {
+      if (!line) continue
+      const xy = line.substring(0, 2)
+      const path = line.substring(3)
+      let status: BranchFile['status'] = 'M'
+      if (xy.includes('?')) status = 'A'
+      else if (xy.includes('D')) status = 'D'
+      else if (xy.includes('U')) status = 'U'
+      files.push({ path, status, source: 'uncommitted' })
+    }
+  }
+
+  return files
+}
+
+/** Get diff for a single file — either committed (branch vs origin/main) or uncommitted (worktree vs HEAD) */
+export function getBranchDiff(
+  cwd: string,
+  branch: string,
+  filePath: string,
+  source: 'committed' | 'uncommitted',
+  worktreePath: string
+): Promise<string> {
+  return new Promise((resolve) => {
+    if (source === 'committed') {
+      execFile('git', ['diff', 'origin/main...' + branch, '--', filePath], { cwd }, (err, stdout) =>
+        resolve(err && !stdout ? '' : stdout || '')
+      )
+    } else {
+      // Uncommitted: run in the worktree directory
+      const dir = worktreePath || cwd
+      execFile('git', ['diff', 'HEAD', '--', filePath], { cwd: dir }, (_err, stdout) => {
+        if (stdout && stdout.trim()) {
+          resolve(stdout)
+        } else {
+          // No diff from HEAD — file is likely untracked, try --no-index
+          execFile(
+            'git',
+            ['diff', '--no-index', '--', '/dev/null', filePath],
+            { cwd: dir },
+            (_err2, stdout2) => resolve(stdout2 || '')
+          )
+        }
+      })
+    }
+  })
+}
+
 export function deleteBranch(cwd: string, branch: string, force: boolean): Promise<void> {
   return new Promise((resolve, reject) => {
     execFile('git', ['branch', force ? '-D' : '-d', branch], { cwd }, (err) => {
diff --git a/src/preload/index.ts b/src/preload/index.ts
index 9974842..e71d7c3 100644
--- a/src/preload/index.ts
+++ b/src/preload/index.ts
@@ -3,7 +3,7 @@ import type { ChangedFile } from '../main/fileWatcher'
 import type { ActivityState } from '../main/activityWatcher'
 import type { SessionInfo } from '../main/sessionManager'
 import type { PersistedState } from '../main/store'
-import type { WorktreeInfo, BranchDetail } from '../main/worktree'
+import type { WorktreeInfo, BranchDetail, BranchFile } from '../main/worktree'
 import type { GitHubRepo, GitHubPR, GitHubIssue } from '../main/github'
 
 export type UpdateStatus = { status: 'available' | 'ready'; version: string }
@@ -49,6 +49,14 @@ export interface KonductorAPI {
   listPullRequests: (cwd: string, state: string) => Promise<GitHubPR[]>
   listIssues: (cwd: string, state: string) => Promise<GitHubIssue[]>
   openExternal: (url: string) => Promise<void>
+  getBranchFiles: (cwd: string, branch: string, worktreePath: string) => Promise<BranchFile[]>
+  getBranchDiff: (
+    cwd: string,
+    branch: string,
+    filePath: string,
+    source: 'committed' | 'uncommitted',
+    worktreePath: string
+  ) => Promise<string>
 }
 
 const api: KonductorAPI = {
@@ -149,7 +157,16 @@ const api: KonductorAPI = {
   listPullRequests: (cwd: string, state: string) =>
     ipcRenderer.invoke('list-pull-requests', cwd, state),
   listIssues: (cwd: string, state: string) => ipcRenderer.invoke('list-issues', cwd, state),
-  openExternal: (url: string) => ipcRenderer.invoke('open-external', url)
+  openExternal: (url: string) => ipcRenderer.invoke('open-external', url),
+  getBranchFiles: (cwd: string, branch: string, worktreePath: string) =>
+    ipcRenderer.invoke('get-branch-files', cwd, branch, worktreePath),
+  getBranchDiff: (
+    cwd: string,
+    branch: string,
+    filePath: string,
+    source: 'committed' | 'uncommitted',
+    worktreePath: string
+  ) => ipcRenderer.invoke('get-branch-diff', cwd, branch, filePath, source, worktreePath)
 }
 
 if (process.contextIsolated) {
diff --git a/src/renderer/src/components/BranchesView.tsx b/src/renderer/src/components/BranchesView.tsx
index 05384a6..f44a98b 100644
--- a/src/renderer/src/components/BranchesView.tsx
+++ b/src/renderer/src/components/BranchesView.tsx
@@ -3,6 +3,14 @@ import type { Project } from '../types'
 
 const api = window.konductorAPI
 
+type PrState = 'open' | 'merged' | 'closed' | 'none'
+
+interface PrInfo {
+  state: PrState
+  number: number
+  url: string
+}
+
 interface BranchDetail {
   name: string
   isHead: boolean
@@ -12,6 +20,9 @@ interface BranchDetail {
   lastCommitRelative: string
   lastCommitSubject: string
   worktreePath: string
+  aheadCount: number
+  dirty: boolean
+  pr: PrInfo
 }
 
 interface WorktreeInfo {
@@ -84,20 +95,36 @@ export default function BranchesView({ project, onBack }: BranchesViewProps): Re
     }
   }, [project.cwd, loadData, showAction])
 
+  const removeBranch = useCallback((name: string) => {
+    setBranches((prev) => prev.filter((b) => b.name !== name))
+    setWorktrees((prev) => prev.filter((w) => w.branch !== name))
+    setSelected((prev) => {
+      const next = new Set(prev)
+      next.delete(name)
+      return next
+    })
+  }, [])
+
+  const clearWorktreeFromBranch = useCallback((worktreePath: string) => {
+    setBranches((prev) =>
+      prev.map((b) => (b.worktreePath === worktreePath ? { ...b, worktreePath: '' } : b))
+    )
+    setWorktrees((prev) => prev.filter((w) => w.path !== worktreePath))
+  }, [])
+
   const handleDeleteBranch = useCallback(
     async (branch: string, force: boolean) => {
       setDeleting(branch)
       setConfirmDelete(null)
       setError(null)
       try {
-        // If the branch has a worktree, remove it first
         const branchInfo = branches.find((b) => b.name === branch)
         if (branchInfo?.worktreePath) {
           await api.removeWorktree(project.cwd, branchInfo.worktreePath)
         }
         await api.deleteBranch(project.cwd, branch, force)
+        removeBranch(branch)
         showAction(`Deleted branch ${branch}`)
-        await loadData()
       } catch (e) {
         const msg = e instanceof Error ? e.message : 'Failed to delete branch'
         if (msg.includes('not fully merged') && !force) {
@@ -109,7 +136,7 @@ export default function BranchesView({ project, onBack }: BranchesViewProps): Re
         setDeleting(null)
       }
     },
-    [project.cwd, branches, loadData, showAction]
+    [project.cwd, branches, removeBranch, showAction]
   )
 
   const handleRemoveWorktree = useCallback(
@@ -117,19 +144,19 @@ export default function BranchesView({ project, onBack }: BranchesViewProps): Re
       setError(null)
       try {
         await api.removeWorktree(project.cwd, worktreePath)
+        clearWorktreeFromBranch(worktreePath)
         showAction('Removed worktree')
-        await loadData()
       } catch (e) {
         setError(e instanceof Error ? e.message : 'Failed to remove worktree')
       }
     },
-    [project.cwd, loadData, showAction]
+    [project.cwd, clearWorktreeFromBranch, showAction]
   )
 
   const handleBulkDelete = useCallback(async () => {
     if (selected.size === 0) return
     setError(null)
-    let deleted = 0
+    const deleted: string[] = []
     for (const branch of selected) {
       try {
         const branchInfo = branches.find((b) => b.name === branch)
@@ -137,14 +164,14 @@ export default function BranchesView({ project, onBack }: BranchesViewProps): Re
           await api.removeWorktree(project.cwd, branchInfo.worktreePath)
         }
         await api.deleteBranch(project.cwd, branch, true)
-        deleted++
+        deleted.push(branch)
       } catch {
         // continue with others
       }
     }
-    showAction(`Deleted ${deleted} branch${deleted !== 1 ? 'es' : ''}`)
-    await loadData()
-  }, [selected, branches, project.cwd, loadData, showAction])
+    for (const name of deleted) removeBranch(name)
+    showAction(`Deleted ${deleted.length} branch${deleted.length !== 1 ? 'es' : ''}`)
+  }, [selected, branches, project.cwd, removeBranch, showAction])
 
   const toggleSelect = useCallback((name: string) => {
     setSelected((prev) => {
@@ -155,9 +182,45 @@ export default function BranchesView({ project, onBack }: BranchesViewProps): Re
     })
   }, [])
 
+  const STALE_DAYS = 3
+
+  // A branch is only stale if there's no active local work (dirty files override everything).
+  // If clean, stale when:
+  // 1. PR merged or closed (work is done or abandoned)
+  // 2. Remote tracking ref gone (branch deleted on remote)
+  // 3. No commits ahead of main (nothing unique on this branch)
+  // 4. Last commit older than STALE_DAYS (abandoned work)
+  const isStale = (b: BranchDetail): boolean => {
+    // Active uncommitted work — never stale
+    if (b.dirty) return false
+
+    if (b.pr.state === 'merged' || b.pr.state === 'closed') return true
+    if (b.gone) return true
+    if (b.aheadCount === 0) return true
+    if (b.lastCommitDate) {
+      const ageMs = Date.now() - new Date(b.lastCommitDate).getTime()
+      const ageDays = ageMs / (1000 * 60 * 60 * 24)
+      if (ageDays > STALE_DAYS) return true
+    }
+    return false
+  }
+
+  const staleReason = (b: BranchDetail): string => {
+    if (b.pr.state === 'merged') return `PR #${b.pr.number} merged`
+    if (b.pr.state === 'closed') return `PR #${b.pr.number} closed without merging`
+    if (b.gone) return 'Remote branch deleted — likely merged'
+    if (b.aheadCount === 0) return 'No commits ahead of main'
+    if (b.lastCommitDate) {
+      const ageMs = Date.now() - new Date(b.lastCommitDate).getTime()
+      const ageDays = Math.floor(ageMs / (1000 * 60 * 60 * 24))
+      if (ageDays > STALE_DAYS) return `Last commit ${ageDays} days ago`
+    }
+    return ''
+  }
+
   // Filter logic
   const filteredBranches = branches.filter((b) => {
-    if (filter === 'stale') return b.gone
+    if (filter === 'stale') return isStale(b)
     if (filter === 'worktrees') return b.worktreePath !== ''
     return true
   })
@@ -166,7 +229,7 @@ export default function BranchesView({ project, onBack }: BranchesViewProps): Re
   const headBranch = filteredBranches.find((b) => b.isHead)
   const otherBranches = filteredBranches.filter((b) => !b.isHead)
 
-  const staleBranches = branches.filter((b) => b.gone)
+  const staleBranches = branches.filter(isStale)
   const worktreeBranches = branches.filter((b) => b.worktreePath)
 
   // Selectable = not HEAD, not main worktree
@@ -279,6 +342,18 @@ export default function BranchesView({ project, onBack }: BranchesViewProps): Re
 
         <div className="flex-1" />
 
+        {filter === 'stale' && staleBranches.length > 0 && selected.size === 0 && (
+          <button
+            onClick={() => {
+              const staleNames = staleBranches.filter(canSelect).map((b) => b.name)
+              setSelected(new Set(staleNames))
+            }}
+            className="flex items-center gap-1.5 px-2.5 py-1 rounded text-xs bg-amber-500/10 border border-amber-500/20 text-amber-400 hover:bg-amber-500/20 hover:text-amber-300 transition-colors"
+          >
+            Select all stale ({staleBranches.filter(canSelect).length})
+          </button>
+        )}
+
         {selected.size > 0 && (
           <button
             onClick={handleBulkDelete}
@@ -315,7 +390,10 @@ export default function BranchesView({ project, onBack }: BranchesViewProps): Re
           {headBranch && (
             <BranchRow
               branch={headBranch}
+              projectCwd={project.cwd}
               isMainWorktree={headBranch.name === mainWorktree?.branch}
+              stale={false}
+              staleReasonText=""
               selected={false}
               canSelect={false}
               deleting={deleting === headBranch.name}
@@ -330,7 +408,10 @@ export default function BranchesView({ project, onBack }: BranchesViewProps): Re
             <BranchRow
               key={b.name}
               branch={b}
+              projectCwd={project.cwd}
               isMainWorktree={b.name === mainWorktree?.branch}
+              stale={isStale(b)}
+              staleReasonText={staleReason(b)}
               selected={selected.has(b.name)}
               canSelect={canSelect(b)}
               deleting={deleting === b.name}
@@ -447,7 +528,10 @@ export default function BranchesView({ project, onBack }: BranchesViewProps): Re
 
 interface BranchRowProps {
   branch: BranchDetail
+  projectCwd: string
   isMainWorktree: boolean
+  stale: boolean
+  staleReasonText: string
   selected: boolean
   canSelect: boolean
   deleting: boolean
@@ -456,9 +540,244 @@ interface BranchRowProps {
   onRemoveWorktree: () => void
 }
 
+type DiffLine = { type: 'add' | 'remove' | 'context' | 'header'; text: string }
+
+interface BranchFileInfo {
+  path: string
+  status: 'A' | 'M' | 'D' | 'R' | 'U'
+  source: 'committed' | 'uncommitted'
+}
+
+function parseDiff(raw: string): DiffLine[] {
+  const lines: DiffLine[] = []
+  for (const line of raw.split('\n')) {
+    if (line.startsWith('@@')) {
+      lines.push({ type: 'header', text: line })
+    } else if (line.startsWith('+') && !line.startsWith('+++')) {
+      lines.push({ type: 'add', text: line.substring(1) })
+    } else if (
+      line.startsWith('diff ') ||
+      line.startsWith('index ') ||
+      line.startsWith('---') ||
+      line.startsWith('+++') ||
+      line.startsWith('\\')
+    ) {
+      // skip metadata
+    } else if (line.startsWith('-') && !line.startsWith('---')) {
+      lines.push({ type: 'remove', text: line.substring(1) })
+    } else {
+      lines.push({ type: 'context', text: line.startsWith(' ') ? line.substring(1) : line })
+    }
+  }
+  return lines
+}
+
+const statusColors: Record<string, string> = {
+  A: 'text-green-400',
+  M: 'text-yellow-400',
+  D: 'text-red-400',
+  R: 'text-blue-400',
+  U: 'text-orange-400'
+}
+
+function BranchDetails({
+  branch,
+  projectCwd
+}: {
+  branch: BranchDetail
+  projectCwd: string
+}): React.JSX.Element {
+  const [files, setFiles] = useState<BranchFileInfo[]>([])
+  const [loading, setLoading] = useState(true)
+  const [selectedFile, setSelectedFile] = useState<BranchFileInfo | null>(null)
+  const [diffResult, setDiffResult] = useState<{ path: string; lines: DiffLine[] } | null>(null)
+
+  useEffect(() => {
+    let cancelled = false
+    api
+      .getBranchFiles(projectCwd, branch.name, branch.worktreePath)
+      .then((f) => {
+        if (!cancelled) {
+          setFiles(f)
+          setLoading(false)
+        }
+      })
+      .catch(() => {
+        if (!cancelled) setLoading(false)
+      })
+    return () => {
+      cancelled = true
+    }
+  }, [projectCwd, branch.name, branch.worktreePath])
+
+  useEffect(() => {
+    if (!selectedFile) return
+    let cancelled = false
+    api
+      .getBranchDiff(
+        projectCwd,
+        branch.name,
+        selectedFile.path,
+        selectedFile.source,
+        branch.worktreePath
+      )
+      .then((raw) => {
+        if (!cancelled) {
+          setDiffResult({ path: selectedFile.path, lines: parseDiff(raw) })
+        }
+      })
+      .catch(() => {
+        if (!cancelled) {
+          setDiffResult({
+            path: selectedFile.path,
+            lines: [{ type: 'context', text: '(unable to load diff)' }]
+          })
+        }
+      })
+    return () => {
+      cancelled = true
+    }
+  }, [selectedFile, projectCwd, branch.name, branch.worktreePath])
+
+  const diffLoading = selectedFile != null && diffResult?.path !== selectedFile.path
+  const diffLines = selectedFile && diffResult?.path === selectedFile.path ? diffResult.lines : []
+
+  // Group files by directory
+  const committedFiles = files.filter((f) => f.source === 'committed')
+  const uncommittedFiles = files.filter((f) => f.source === 'uncommitted')
+
+  if (loading) {
+    return <div className="px-8 py-3 text-xs text-gray-500">Loading files...</div>
+  }
+
+  if (files.length === 0) {
+    return <div className="px-8 py-3 text-xs text-gray-600">No changed files</div>
+  }
+
+  return (
+    <div className="flex border-t border-surface-border/30" style={{ height: 280 }}>
+      {/* File tree */}
+      <div className="w-64 shrink-0 overflow-y-auto border-r border-surface-border/30 py-1">
+        {committedFiles.length > 0 && (
+          <>
+            <div className="px-3 py-1 text-[9px] uppercase tracking-wider text-gray-600">
+              Committed ({committedFiles.length})
+            </div>
+            {committedFiles.map((f) => (
+              <button
+                key={'c:' + f.path}
+                onClick={() => setSelectedFile(f)}
+                className={`w-full text-left px-3 py-0.5 text-xs font-mono flex items-center gap-2 transition-colors ${
+                  selectedFile === f
+                    ? 'bg-accent/20 text-white'
+                    : 'text-gray-400 hover:bg-surface-raised/50'
+                }`}
+              >
+                <span
+                  className={`${statusColors[f.status] || 'text-gray-500'} font-bold w-3 shrink-0 text-[10px]`}
+                >
+                  {f.status}
+                </span>
+                <span className="truncate text-[11px]">{f.path}</span>
+              </button>
+            ))}
+          </>
+        )}
+        {uncommittedFiles.length > 0 && (
+          <>
+            <div className="px-3 py-1 text-[9px] uppercase tracking-wider text-blue-400/60 mt-1">
+              Uncommitted ({uncommittedFiles.length})
+            </div>
+            {uncommittedFiles.map((f) => (
+              <button
+                key={'u:' + f.path}
+                onClick={() => setSelectedFile(f)}
+                className={`w-full text-left px-3 py-0.5 text-xs font-mono flex items-center gap-2 transition-colors ${
+                  selectedFile === f
+                    ? 'bg-accent/20 text-white'
+                    : 'text-gray-400 hover:bg-surface-raised/50'
+                }`}
+              >
+                <span
+                  className={`${statusColors[f.status] || 'text-gray-500'} font-bold w-3 shrink-0 text-[10px]`}
+                >
+                  {f.status}
+                </span>
+                <span className="truncate text-[11px]">{f.path}</span>
+              </button>
+            ))}
+          </>
+        )}
+      </div>
+
+      {/* Diff view */}
+      <div className="flex-1 overflow-auto bg-surface-raised">
+        {selectedFile ? (
+          <>
+            <div className="px-3 py-1.5 text-[10px] text-gray-500 border-b border-surface-border/30 sticky top-0 bg-surface-raised font-mono">
+              {selectedFile.path}
+              <span className="ml-2 text-gray-600">({selectedFile.source})</span>
+            </div>
+            {diffLoading ? (
+              <div className="p-4 text-gray-500 text-xs">Loading diff...</div>
+            ) : diffLines.length === 0 ? (
+              <div className="p-4 text-gray-500 text-xs">No diff available</div>
+            ) : (
+              <div className="text-xs font-mono">
+                {diffLines.map((line, i) => {
+                  if (line.type === 'header') {
+                    return (
+                      <div
+                        key={i}
+                        className="px-3 py-0.5 text-blue-400 bg-blue-400/5 border-y border-blue-400/10"
+                      >
+                        {line.text}
+                      </div>
+                    )
+                  }
+                  const bg =
+                    line.type === 'add'
+                      ? 'bg-green-400/10'
+                      : line.type === 'remove'
+                        ? 'bg-red-400/10'
+                        : ''
+                  const markerColor =
+                    line.type === 'add'
+                      ? 'text-green-400'
+                      : line.type === 'remove'
+                        ? 'text-red-400'
+                        : 'text-transparent'
+                  const marker = line.type === 'add' ? '+' : line.type === 'remove' ? '-' : ' '
+                  return (
+                    <div key={i} className={`flex ${bg}`}>
+                      <span className={`shrink-0 w-5 text-center select-none ${markerColor}`}>
+                        {marker}
+                      </span>
+                      <span className="px-2 whitespace-pre-wrap break-all text-gray-300">
+                        {line.text}
+                      </span>
+                    </div>
+                  )
+                })}
+              </div>
+            )}
+          </>
+        ) : (
+          <div className="flex items-center justify-center h-full text-gray-600 text-xs">
+            Select a file to view diff
+          </div>
+        )}
+      </div>
+    </div>
+  )
+}
+
 function BranchRow({
   branch,
+  projectCwd,
   isMainWorktree,
+  stale,
+  staleReasonText,
   selected,
   canSelect,
   deleting,
@@ -466,120 +785,224 @@ function BranchRow({
   onDelete,
   onRemoveWorktree
 }: BranchRowProps): React.JSX.Element {
+  const [expanded, setExpanded] = useState(false)
+  const hasFiles = branch.aheadCount > 0 || branch.dirty
+
   return (
-    <div
-      className={`flex items-center gap-3 px-4 py-2.5 border-b border-surface-border/50 transition-colors ${
-        selected ? 'bg-accent/5' : 'hover:bg-surface-raised/50'
-      } ${deleting ? 'opacity-40' : ''}`}
-    >
-      {/* Checkbox */}
-      <div className="w-5 flex items-center justify-center">
-        {canSelect ? (
-          <input
-            type="checkbox"
-            checked={selected}
-            onChange={onToggle}
-            className="accent-accent w-3 h-3"
-          />
-        ) : (
-          <div className="w-3" />
-        )}
-      </div>
+    <div className={`border-b border-surface-border/50 ${deleting ? 'opacity-40' : ''}`}>
+      <div
+        className={`flex items-center gap-3 px-4 py-2.5 transition-colors ${
+          selected ? 'bg-accent/5' : stale ? 'bg-amber-500/[0.03]' : 'hover:bg-surface-raised/50'
+        }`}
+      >
+        {/* Checkbox */}
+        <div className="w-5 flex items-center justify-center">
+          {canSelect ? (
+            <input
+              type="checkbox"
+              checked={selected}
+              onChange={onToggle}
+              className="accent-accent w-3 h-3"
+            />
+          ) : (
+            <div className="w-3" />
+          )}
+        </div>
 
-      {/* Branch name + badges */}
-      <div className="flex-1 min-w-0">
-        <div className="flex items-center gap-2">
-          <span
-            className={`text-xs truncate ${branch.isHead ? 'text-accent font-semibold' : 'text-gray-200'}`}
+        {/* Expand toggle */}
+        <button
+          onClick={() => hasFiles && setExpanded((p) => !p)}
+          className={`w-4 flex items-center justify-center ${hasFiles ? 'text-gray-500 hover:text-gray-300' : 'text-gray-700 cursor-default'}`}
+          title={
+            hasFiles ? (expanded ? 'Collapse details' : 'Show changed files') : 'No changed files'
+          }
+        >
+          <svg
+            width="8"
+            height="8"
+            viewBox="0 0 8 8"
+            fill="currentColor"
+            className={`transition-transform ${expanded ? 'rotate-90' : ''}`}
           >
-            {branch.name}
-          </span>
+            <path d="M2 1l4 3-4 3V1z" />
+          </svg>
+        </button>
 
-          {branch.isHead && (
-            <span className="text-[9px] px-1.5 py-0.5 rounded bg-accent/20 text-accent border border-accent/30">
-              HEAD
+        {/* Branch name + badges */}
+        <div className="flex-1 min-w-0">
+          <div className="flex items-center gap-2">
+            <span
+              className={`text-xs truncate ${branch.isHead ? 'text-accent font-semibold' : stale ? 'text-gray-400' : 'text-gray-200'}`}
+            >
+              {branch.name}
             </span>
-          )}
 
-          {branch.gone && (
-            <span className="text-[9px] px-1.5 py-0.5 rounded bg-amber-500/10 text-amber-400 border border-amber-500/20">
-              gone
-            </span>
-          )}
+            {branch.isHead && (
+              <span
+                className="text-[9px] px-1.5 py-0.5 rounded bg-accent/20 text-accent border border-accent/30 cursor-help"
+                title="HEAD: The currently checked-out branch in this worktree"
+              >
+                HEAD
+              </span>
+            )}
+
+            {stale && (
+              <span
+                className="text-[9px] px-1.5 py-0.5 rounded bg-amber-500/10 text-amber-400 border border-amber-500/20 cursor-help"
+                title={`Stale: ${staleReasonText}`}
+              >
+                stale
+              </span>
+            )}
+
+            {branch.gone && !stale && (
+              <span
+                className="text-[9px] px-1.5 py-0.5 rounded bg-amber-500/10 text-amber-400 border border-amber-500/20 cursor-help"
+                title="Gone: The remote tracking branch no longer exists — it was likely deleted after merging"
+              >
+                gone
+              </span>
+            )}
+
+            {branch.worktreePath && (
+              <span
+                className={`text-[9px] px-1.5 py-0.5 rounded border cursor-help ${
+                  stale
+                    ? 'bg-amber-500/10 text-amber-400 border-amber-500/20'
+                    : 'bg-green-500/10 text-green-400 border-green-500/20'
+                }`}
+                title="Worktree: This branch is checked out in a separate working directory for parallel development"
+              >
+                worktree
+              </span>
+            )}
+
+            {branch.dirty && (
+              <span
+                className="text-[9px] px-1.5 py-0.5 rounded bg-blue-500/10 text-blue-400 border border-blue-500/20 cursor-help"
+                title="Dirty: This worktree has uncommitted changes — modified, added, or deleted files that haven't been committed yet"
+              >
+                dirty
+              </span>
+            )}
+
+            {!isMainWorktree && branch.aheadCount > 0 && (
+              <span
+                className="text-[9px] px-1.5 py-0.5 rounded bg-purple-500/10 text-purple-400 border border-purple-500/20 cursor-help"
+                title={`Ahead: This branch has ${branch.aheadCount} commit${branch.aheadCount !== 1 ? 's' : ''} not yet merged into main`}
+              >
+                +{branch.aheadCount} ahead
+              </span>
+            )}
+
+            {branch.pr.state === 'open' && (
+              <span
+                className="text-[9px] px-1.5 py-0.5 rounded bg-green-500/10 text-green-400 border border-green-500/20 cursor-help"
+                title={`Open PR: Pull request #${branch.pr.number} is open and in review`}
+              >
+                PR #{branch.pr.number}
+              </span>
+            )}
+
+            {branch.pr.state === 'merged' && (
+              <span
+                className="text-[9px] px-1.5 py-0.5 rounded bg-purple-500/10 text-purple-400 border border-purple-500/20 cursor-help"
+                title={`Merged: Pull request #${branch.pr.number} has been merged — branch can be cleaned up`}
+              >
+                PR #{branch.pr.number} merged
+              </span>
+            )}
+
+            {branch.pr.state === 'closed' && (
+              <span
+                className="text-[9px] px-1.5 py-0.5 rounded bg-gray-500/10 text-gray-400 border border-gray-500/20 cursor-help"
+                title={`Closed: Pull request #${branch.pr.number} was closed without merging`}
+              >
+                PR #{branch.pr.number} closed
+              </span>
+            )}
+
+            {isMainWorktree && (
+              <span
+                className="text-[9px] px-1.5 py-0.5 rounded bg-surface-raised text-gray-500 border border-surface-border cursor-help"
+                title="Main: The primary worktree (original repo checkout) — cannot be removed"
+              >
+                main
+              </span>
+            )}
+          </div>
 
-          {branch.worktreePath && (
-            <span className="text-[9px] px-1.5 py-0.5 rounded bg-green-500/10 text-green-400 border border-green-500/20">
-              worktree
-            </span>
+          {/* Stale reason */}
+          {stale && staleReasonText && (
+            <div className="text-[10px] text-amber-400/60 mt-0.5">{staleReasonText}</div>
           )}
 
-          {isMainWorktree && (
-            <span className="text-[9px] px-1.5 py-0.5 rounded bg-surface-raised text-gray-500 border border-surface-border">
-              main
-            </span>
+          {/* Commit subject */}
+          <div className="text-[10px] text-gray-600 truncate mt-0.5">
+            {branch.lastCommitSubject}
+          </div>
+
+          {/* Worktree path */}
+          {branch.worktreePath && (
+            <div className="text-[10px] text-gray-600 truncate mt-0.5">{branch.worktreePath}</div>
           )}
         </div>
 
-        {/* Commit subject */}
-        <div className="text-[10px] text-gray-600 truncate mt-0.5">{branch.lastCommitSubject}</div>
-
-        {/* Worktree path */}
-        {branch.worktreePath && (
-          <div className="text-[10px] text-gray-600 truncate mt-0.5">{branch.worktreePath}</div>
-        )}
-      </div>
-
-      {/* Upstream */}
-      <div className="w-32 text-[10px] text-gray-500 truncate">
-        {branch.upstream || <span className="text-gray-700 italic">no upstream</span>}
-      </div>
+        {/* Upstream */}
+        <div className="w-32 text-[10px] text-gray-500 truncate">
+          {branch.upstream || <span className="text-gray-700 italic">no upstream</span>}
+        </div>
 
-      {/* Last commit */}
-      <div className="w-28 text-[10px] text-gray-500" title={branch.lastCommitDate}>
-        {branch.lastCommitRelative}
-      </div>
+        {/* Last commit */}
+        <div className="w-28 text-[10px] text-gray-500" title={branch.lastCommitDate}>
+          {branch.lastCommitRelative}
+        </div>
 
-      {/* Actions */}
-      <div className="w-20 flex justify-end gap-1">
-        {branch.worktreePath && !isMainWorktree && (
-          <button
-            onClick={onRemoveWorktree}
-            className="text-[10px] px-1.5 py-1 rounded text-gray-500 hover:text-amber-400 hover:bg-amber-500/10 transition-colors"
-            title="Remove worktree"
-          >
-            <svg
-              width="12"
-              height="12"
-              viewBox="0 0 16 16"
-              fill="none"
-              stroke="currentColor"
-              strokeWidth="1.5"
+        {/* Actions */}
+        <div className="w-20 flex justify-end gap-1">
+          {branch.worktreePath && !isMainWorktree && (
+            <button
+              onClick={onRemoveWorktree}
+              className="text-[10px] px-1.5 py-1 rounded text-gray-500 hover:text-amber-400 hover:bg-amber-500/10 transition-colors"
+              title="Remove worktree"
             >
-              <path d="M3 4h10M5.5 4V3a1 1 0 011-1h3a1 1 0 011 1v1M6 7v5M10 7v5M4 4l.8 9a1 1 0 001 .9h4.4a1 1 0 001-.9L12 4" />
-            </svg>
-          </button>
-        )}
+              <svg
+                width="12"
+                height="12"
+                viewBox="0 0 16 16"
+                fill="none"
+                stroke="currentColor"
+                strokeWidth="1.5"
+              >
+                <path d="M3 4h10M5.5 4V3a1 1 0 011-1h3a1 1 0 011 1v1M6 7v5M10 7v5M4 4l.8 9a1 1 0 001 .9h4.4a1 1 0 001-.9L12 4" />
+              </svg>
+            </button>
+          )}
 
-        {canSelect && !isMainWorktree && (
-          <button
-            onClick={() => onDelete(false)}
-            disabled={deleting}
-            className="text-[10px] px-1.5 py-1 rounded text-gray-500 hover:text-red-400 hover:bg-red-500/10 transition-colors disabled:opacity-40"
-            title="Delete branch"
-          >
-            <svg
-              width="12"
-              height="12"
-              viewBox="0 0 16 16"
-              fill="none"
-              stroke="currentColor"
-              strokeWidth="1.5"
+          {canSelect && !isMainWorktree && (
+            <button
+              onClick={() => onDelete(false)}
+              disabled={deleting}
+              className="text-[10px] px-1.5 py-1 rounded text-gray-500 hover:text-red-400 hover:bg-red-500/10 transition-colors disabled:opacity-40"
+              title="Delete branch"
             >
-              <path d="M4 4l8 8M12 4l-8 8" />
-            </svg>
-          </button>
-        )}
+              <svg
+                width="12"
+                height="12"
+                viewBox="0 0 16 16"
+                fill="none"
+                stroke="currentColor"
+                strokeWidth="1.5"
+              >
+                <path d="M4 4l8 8M12 4l-8 8" />
+              </svg>
+            </button>
+          )}
+        </div>
       </div>
+
+      {/* Expandable details panel */}
+      {expanded && <BranchDetails branch={branch} projectCwd={projectCwd} />}
     </div>
   )
 }