diff --git a/docs/CUSTOM_THEMES.md b/docs/CUSTOM_THEMES.md
index 905a6af5..db04adec 100644
--- a/docs/CUSTOM_THEMES.md
+++ b/docs/CUSTOM_THEMES.md
@@ -82,6 +82,13 @@ OpenChamber supports user-defined themes. Drop a JSON file into the themes direc
       "infoBackground": "#205EA620",
       "infoBorder": "#205EA650"
     },
+    "pr": {
+      "open": "#A0AF54",
+      "draft": "#878580",
+      "blocked": "#DA702C",
+      "merged": "#8B7EC8",
+      "closed": "#D14D41"
+    },
     "syntax": {
       "base": {
         "background": "#1C1B1A",
diff --git a/packages/ui/src/components/session/SessionSidebar.tsx b/packages/ui/src/components/session/SessionSidebar.tsx
index 6eef58e4..13e22bbf 100644
--- a/packages/ui/src/components/session/SessionSidebar.tsx
+++ b/packages/ui/src/components/session/SessionSidebar.tsx
@@ -10,15 +10,16 @@ import {
   PointerSensor,
   useSensor,
   useSensors,
-  type DragEndEvent,
-  type DragStartEvent,
+  type Modifier,
 } from '@dnd-kit/core';
 import {
   SortableContext,
+  arrayMove,
   sortableKeyboardCoordinates,
   useSortable,
   verticalListSortingStrategy,
 } from '@dnd-kit/sortable';
+import { CSS } from '@dnd-kit/utilities';
 import {
   DropdownMenu,
   DropdownMenuContent,
@@ -40,6 +41,9 @@ import {
   RiFileCopyLine,
   RiFolderAddLine,
   RiGitBranchLine,
+  RiGitClosePullRequestLine,
+  RiGitMergeLine,
+  RiGitPrDraftLine,
   RiGitPullRequestLine,
   RiLinkUnlinkM,
 
@@ -62,14 +66,29 @@ import type { WorktreeMetadata } from '@/types/worktree';
 import { opencodeClient } from '@/lib/opencode/client';
 import { checkIsGitRepository } from '@/lib/gitApi';
 import { getSafeStorage } from '@/stores/utils/safeStorage';
-import { createWorktreeSession } from '@/lib/worktreeSessionCreator';
+import { createWorktreeOnly, createWorktreeSession } from '@/lib/worktreeSessionCreator';
+import { getRootBranch } from '@/lib/worktrees/worktreeStatus';
 import { isVSCodeRuntime } from '@/lib/desktop';
 import { updateDesktopSettings } from '@/lib/persistence';
+import { useRuntimeAPIs } from '@/hooks/useRuntimeAPIs';
+import type { GitHubPullRequestStatus } from '@/lib/api/types';
 import { GitHubIssuePickerDialog } from './GitHubIssuePickerDialog';
 import { GitHubPullRequestPickerDialog } from './GitHubPullRequestPickerDialog';
 
+const ATTENTION_DIAMOND_INDICES = new Set([1, 3, 4, 5, 7]);
+
+const getAttentionDiamondDelay = (index: number): string => {
+  return index === 4 ? '0ms' : '130ms';
+};
+
 const PROJECT_COLLAPSE_STORAGE_KEY = 'oc.sessions.projectCollapse';
+const GROUP_ORDER_STORAGE_KEY = 'oc.sessions.groupOrder';
+const GROUP_COLLAPSE_STORAGE_KEY = 'oc.sessions.groupCollapse';
+const PROJECT_ACTIVE_SESSION_STORAGE_KEY = 'oc.sessions.activeSessionByProject';
 const SESSION_EXPANDED_STORAGE_KEY = 'oc.sessions.expandedParents';
+const PR_REVALIDATE_TTL_MS = 90_000;
+const PR_REVALIDATE_INTERVAL_MS = 90_000;
+const PR_REVALIDATE_CONCURRENCY = 3;
 
 const formatDateLabel = (value: string | number) => {
   const targetDate = new Date(value);
@@ -104,6 +123,84 @@ const normalizePath = (value?: string | null) => {
   return normalized.length === 0 ? '/' : normalized;
 };
 
+const toFiniteNumber = (value: unknown): number | undefined => {
+  if (typeof value === 'number' && Number.isFinite(value)) {
+    return value;
+  }
+  if (typeof value === 'string' && value.trim().length > 0) {
+    const parsed = Number(value);
+    if (Number.isFinite(parsed)) {
+      return parsed;
+    }
+  }
+  return undefined;
+};
+
+const getPrVisualState = (status: GitHubPullRequestStatus | null): 'draft' | 'open' | 'blocked' | 'merged' | 'closed' | null => {
+  const pr = status?.pr;
+  if (!pr) {
+    return null;
+  }
+  if (pr.state === 'merged') {
+    return 'merged';
+  }
+  if (pr.state === 'closed') {
+    return 'closed';
+  }
+  if (pr.draft) {
+    return 'draft';
+  }
+  const checksFailed = status?.checks?.state === 'failure';
+  const notMergeable = status?.canMerge === false || pr.mergeable === false;
+  if (checksFailed || notMergeable) {
+    return 'blocked';
+  }
+  return 'open';
+};
+
+const getPrTooltipLabel = (status: GitHubPullRequestStatus | null): string => {
+  const pr = status?.pr;
+  if (!pr) {
+    return 'Open pull request';
+  }
+  const parts: string[] = [`PR #${pr.number}`];
+  if (pr.state === 'merged') {
+    parts.push('Merged');
+  } else if (pr.state === 'closed') {
+    parts.push('Closed');
+  } else if (pr.draft) {
+    parts.push('Draft');
+  } else {
+    parts.push('Open');
+  }
+  if (status?.checks?.state === 'failure') {
+    parts.push('Checks failing');
+  }
+  if (status?.canMerge === false || pr.mergeable === false) {
+    parts.push('Merge blocked');
+  }
+  return parts.join(' · ');
+};
+
+type TauriShell = {
+  shell?: {
+    open?: (url: string) => Promise<unknown>;
+  };
+};
+
+const centerDragOverlayUnderPointer: Modifier = ({ transform, activeNodeRect, activatorEvent }) => {
+  if (!(activatorEvent instanceof MouseEvent) || !activeNodeRect) {
+    return transform;
+  }
+  const overlayHeight = 32;
+  const pointerLiftY = 16;
+  return {
+    ...transform,
+    x: transform.x,
+    y: transform.y - overlayHeight / 2 - pointerLiftY,
+  };
+};
+
 // Format project label: kebab-case/snake_case → Title Case
 const formatProjectLabel = (label: string): string => {
   return label
@@ -156,6 +253,8 @@ interface SortableProjectItemProps {
   sentinelRef: (el: HTMLDivElement | null) => void;
   children?: React.ReactNode;
   settingsAutoCreateWorktree: boolean;
+  showCreateButtons?: boolean;
+  hideHeader?: boolean;
 }
 
 const SortableProjectItem: React.FC<SortableProjectItemProps> = ({
@@ -187,6 +286,8 @@ const SortableProjectItem: React.FC<SortableProjectItemProps> = ({
   sentinelRef,
   children,
   settingsAutoCreateWorktree,
+  showCreateButtons = true,
+  hideHeader = false,
 }) => {
   const {
     attributes,
@@ -199,41 +300,43 @@ const SortableProjectItem: React.FC<SortableProjectItemProps> = ({
 
   return (
     <div ref={setNodeRef} className={cn('relative', isDragging && 'opacity-40')}>
-      {/* Sentinel for sticky detection */}
-      {isDesktopShell && (
-        <div
-          ref={sentinelRef}
-          data-project-id={id}
-          className="absolute top-0 h-px w-full pointer-events-none"
-          aria-hidden="true"
-        />
-      )}
-      
-      {/* Project header - sticky like workspace groups */}
-      <div
-        className={cn(
-          'sticky top-0 z-10 pt-2 pb-1.5 w-full text-left cursor-pointer group/project border-b select-none',
-          !isDesktopShell && 'bg-sidebar',
-        )}
-        style={{
-          backgroundColor: isDesktopShell
-            ? isStuck ? 'var(--sidebar-stuck-bg)' : 'transparent'
-            : undefined,
-          borderColor: isHovered
-            ? 'var(--color-border-hover)'
-            : isCollapsed
-              ? 'color-mix(in srgb, var(--color-border) 35%, transparent)'
-              : 'var(--color-border)'
-        }}
-        onMouseEnter={() => onHoverChange(true)}
-        onMouseLeave={() => onHoverChange(false)}
-        onContextMenu={(event) => {
-          event.preventDefault();
-          if (!isRenaming) {
-            setIsMenuOpen(true);
-          }
-        }}
-      >
+      {!hideHeader ? (
+        <>
+          {/* Sentinel for sticky detection */}
+          {isDesktopShell && (
+            <div
+              ref={sentinelRef}
+              data-project-id={id}
+              className="absolute top-0 h-px w-full pointer-events-none"
+              aria-hidden="true"
+            />
+          )}
+
+          {/* Project header - sticky like workspace groups */}
+          <div
+            className={cn(
+              'sticky top-0 z-10 pt-2 pb-1.5 w-full text-left cursor-pointer group/project border-b select-none',
+              !isDesktopShell && 'bg-sidebar',
+            )}
+            style={{
+              backgroundColor: isDesktopShell
+                ? isStuck ? 'var(--sidebar-stuck-bg)' : 'transparent'
+                : undefined,
+              borderColor: isHovered
+                ? 'var(--color-border-hover)'
+                : isCollapsed
+                  ? 'color-mix(in srgb, var(--color-border) 35%, transparent)'
+                  : 'var(--color-border)'
+            }}
+            onMouseEnter={() => onHoverChange(true)}
+            onMouseLeave={() => onHoverChange(false)}
+            onContextMenu={(event) => {
+              event.preventDefault();
+              if (!isRenaming) {
+                setIsMenuOpen(true);
+              }
+            }}
+          >
         <div className="relative flex items-center gap-1 px-1" {...attributes}>
           {isRenaming ? (
             <form
@@ -312,31 +415,31 @@ const SortableProjectItem: React.FC<SortableProjectItemProps> = ({
                 </button>
               </DropdownMenuTrigger>
               <DropdownMenuContent align="end" className="min-w-[180px]">
-                {isRepo && !hideDirectoryControls && settingsAutoCreateWorktree && onNewSession && (
+                {showCreateButtons && isRepo && !hideDirectoryControls && settingsAutoCreateWorktree && onNewSession && (
                   <DropdownMenuItem onClick={onNewSession}>
                     <RiAddLine className="mr-1.5 h-4 w-4" />
                     New Session
                   </DropdownMenuItem>
                 )}
-                {isRepo && !hideDirectoryControls && !settingsAutoCreateWorktree && onNewWorktreeSession && (
+                {showCreateButtons && isRepo && !hideDirectoryControls && !settingsAutoCreateWorktree && onNewWorktreeSession && (
                   <DropdownMenuItem onClick={onNewWorktreeSession}>
                     <RiGitBranchLine className="mr-1.5 h-4 w-4" />
                     New Session in Worktree
                   </DropdownMenuItem>
                 )}
-                {isRepo && !hideDirectoryControls && onNewSessionFromGitHubIssue && (
+                {showCreateButtons && isRepo && !hideDirectoryControls && onNewSessionFromGitHubIssue && (
                   <DropdownMenuItem onClick={onNewSessionFromGitHubIssue}>
                     <RiGithubLine className="mr-1.5 h-4 w-4" />
                     New session from GitHub issue
                   </DropdownMenuItem>
                 )}
-                {isRepo && !hideDirectoryControls && onNewSessionFromGitHubPR && (
+                {showCreateButtons && isRepo && !hideDirectoryControls && onNewSessionFromGitHubPR && (
                   <DropdownMenuItem onClick={onNewSessionFromGitHubPR}>
                     <RiGitPullRequestLine className="mr-1.5 h-4 w-4" />
                     New session from GitHub PR
                   </DropdownMenuItem>
                 )}
-                {isRepo && !hideDirectoryControls && (
+                {showCreateButtons && isRepo && !hideDirectoryControls && (
                   <DropdownMenuItem onClick={onOpenMultiRunLauncher}>
                     <ArrowsMerge className="mr-1.5 h-4 w-4" />
                     New Multi-Run
@@ -357,7 +460,7 @@ const SortableProjectItem: React.FC<SortableProjectItemProps> = ({
             </DropdownMenu>
           ) : null}
 
-          {isRepo && !hideDirectoryControls && onNewWorktreeSession && settingsAutoCreateWorktree && !isRenaming && (
+          {showCreateButtons && isRepo && !hideDirectoryControls && onNewWorktreeSession && settingsAutoCreateWorktree && !isRenaming && (
             <Tooltip>
               <TooltipTrigger asChild>
                 <button
@@ -380,7 +483,7 @@ const SortableProjectItem: React.FC<SortableProjectItemProps> = ({
               </TooltipContent>
             </Tooltip>
           )}
-          {(!settingsAutoCreateWorktree || !isRepo) && !isRenaming && (
+          {showCreateButtons && (!settingsAutoCreateWorktree || !isRepo) && !isRenaming && (
             <Tooltip>
               <TooltipTrigger asChild>
                 <button
@@ -401,7 +504,9 @@ const SortableProjectItem: React.FC<SortableProjectItemProps> = ({
             </Tooltip>
           )}
         </div>
-      </div>
+          </div>
+        </>
+      ) : null}
 
       {/* Children (workspace groups and sessions) */}
       {children}
@@ -409,33 +514,48 @@ const SortableProjectItem: React.FC<SortableProjectItemProps> = ({
   );
 };
 
-// Drag overlay component - shows only the header during drag
-interface ProjectDragOverlayProps {
-  projectLabel: string;
-  isActiveProject: boolean;
-}
+const SortableGroupItemBase: React.FC<{
+  id: string;
+  children: React.ReactNode;
+}> = ({ id, children }) => {
+  const {
+    attributes,
+    listeners,
+    setNodeRef,
+    transform,
+    transition,
+    isDragging,
+  } = useSortable({ id });
 
-const ProjectDragOverlay: React.FC<ProjectDragOverlayProps> = ({
-  projectLabel,
-  isActiveProject,
-}) => {
   return (
     <div
-      className="bg-sidebar border border-border rounded-md shadow-lg px-2 py-1.5"
-      style={{ width: 'max-content', maxWidth: '280px' }}
+      ref={setNodeRef}
+      style={{ transform: CSS.Transform.toString(transform), transition, willChange: 'transform' }}
+      className={cn(
+        'space-y-0.5 rounded-md',
+        isDragging && 'opacity-0',
+      )}
+      {...attributes}
+      {...listeners}
     >
-      <div className="flex items-center gap-2">
-        <span className={cn(
-          "typography-ui font-semibold truncate",
-          isActiveProject ? "text-primary" : "text-foreground"
-        )}>
-          {projectLabel}
-        </span>
-      </div>
+      {children}
     </div>
   );
 };
 
+const SortableGroupItem = React.memo(SortableGroupItemBase);
+
+const GroupDragOverlayBase: React.FC<{ label: string; showBranchIcon: boolean; width?: number }> = ({ label, showBranchIcon, width }) => {
+  return (
+    <div style={width ? { width: `${width}px` } : undefined} className="h-8 min-w-[180px] max-w-[320px] rounded-sm border border-border bg-sidebar px-2 shadow-lg flex items-center gap-1.5">
+      {showBranchIcon ? <RiGitBranchLine className="h-3.5 w-3.5 flex-shrink-0 text-muted-foreground" /> : null}
+      <p className="text-[15px] font-semibold truncate text-foreground">{label}</p>
+    </div>
+  );
+};
+
+const GroupDragOverlay = React.memo(GroupDragOverlayBase);
+
 interface SessionSidebarProps {
   mobileVariant?: boolean;
   onSessionSelected?: (sessionId: string) => void;
@@ -470,9 +590,63 @@ export const SessionSidebar: React.FC<SessionSidebarProps> = ({
   const [hoveredProjectId, setHoveredProjectId] = React.useState<string | null>(null);
   const [issuePickerOpen, setIssuePickerOpen] = React.useState(false);
   const [pullRequestPickerOpen, setPullRequestPickerOpen] = React.useState(false);
-  const [activeDragId, setActiveDragId] = React.useState<string | null>(null);
+  const [worktreePrByGroupKey, setWorktreePrByGroupKey] = React.useState<Map<string, GitHubPullRequestStatus>>(new Map());
   const [stuckProjectHeaders, setStuckProjectHeaders] = React.useState<Set<string>>(new Set());
   const [openMenuSessionId, setOpenMenuSessionId] = React.useState<string | null>(null);
+  const [collapsedGroups, setCollapsedGroups] = React.useState<Set<string>>(() => {
+    try {
+      const raw = getSafeStorage().getItem(GROUP_COLLAPSE_STORAGE_KEY);
+      if (!raw) {
+        return new Set();
+      }
+      const parsed = JSON.parse(raw) as string[];
+      return new Set(Array.isArray(parsed) ? parsed.filter((item) => typeof item === 'string') : []);
+    } catch {
+      return new Set();
+    }
+  });
+  const [groupOrderByProject, setGroupOrderByProject] = React.useState<Map<string, string[]>>(() => {
+    try {
+      const raw = getSafeStorage().getItem(GROUP_ORDER_STORAGE_KEY);
+      if (!raw) {
+        return new Map();
+      }
+      const parsed = JSON.parse(raw) as Record<string, string[]>;
+      const next = new Map<string, string[]>();
+      Object.entries(parsed).forEach(([projectId, order]) => {
+        if (Array.isArray(order)) {
+          next.set(projectId, order.filter((item) => typeof item === 'string'));
+        }
+      });
+      return next;
+    } catch {
+      return new Map();
+    }
+  });
+  const [activeSessionByProject, setActiveSessionByProject] = React.useState<Map<string, string>>(() => {
+    try {
+      const raw = getSafeStorage().getItem(PROJECT_ACTIVE_SESSION_STORAGE_KEY);
+      if (!raw) {
+        return new Map();
+      }
+      const parsed = JSON.parse(raw) as Record<string, string>;
+      const next = new Map<string, string>();
+      Object.entries(parsed).forEach(([projectId, sessionId]) => {
+        if (typeof sessionId === 'string' && sessionId.length > 0) {
+          next.set(projectId, sessionId);
+        }
+      });
+      return next;
+    } catch {
+      return new Map();
+    }
+  });
+  const [activeDraggedGroupId, setActiveDraggedGroupId] = React.useState<string | null>(null);
+  const [activeDraggedGroupWidth, setActiveDraggedGroupWidth] = React.useState<number | null>(null);
+  const [isProjectRenameInline, setIsProjectRenameInline] = React.useState(false);
+  const [projectRenameDraft, setProjectRenameDraft] = React.useState('');
+  const [projectRootBranches, setProjectRootBranches] = React.useState<Map<string, string>>(new Map());
+  const worktreePrLastCheckedAtRef = React.useRef<Map<string, number>>(new Map());
   const projectHeaderSentinelRefs = React.useRef<Map<string, HTMLDivElement | null>>(new Map());
   const ignoreIntersectionUntil = React.useRef<number>(0);
   const persistCollapsedProjectsTimer = React.useRef<number | null>(null);
@@ -489,11 +663,11 @@ export const SessionSidebar: React.FC<SessionSidebarProps> = ({
   const setActiveProject = useProjectsStore((state) => state.setActiveProject);
   const setActiveProjectIdOnly = useProjectsStore((state) => state.setActiveProjectIdOnly);
   const renameProject = useProjectsStore((state) => state.renameProject);
-  const reorderProjects = useProjectsStore((state) => state.reorderProjects);
 
   const setActiveMainTab = useUIStore((state) => state.setActiveMainTab);
   const setSessionSwitcherOpen = useUIStore((state) => state.setSessionSwitcherOpen);
   const openMultiRunLauncher = useUIStore((state) => state.openMultiRunLauncher);
+  const { github, git } = useRuntimeAPIs();
 
   const settingsAutoCreateWorktree = useConfigStore((state) => state.settingsAutoCreateWorktree);
 
@@ -506,6 +680,7 @@ export const SessionSidebar: React.FC<SessionSidebarProps> = ({
   const unshareSession = useSessionStore((state) => state.unshareSession);
   const sessionMemoryState = useSessionStore((state) => state.sessionMemoryState);
   const sessionStatus = useSessionStore((state) => state.sessionStatus);
+  const sessionAttentionStates = useSessionStore((state) => state.sessionAttentionStates);
   const permissions = useSessionStore((state) => state.permissions);
   const worktreeMetadata = useSessionStore((state) => state.worktreeMetadata);
   const availableWorktreesByProject = useSessionStore((state) => state.availableWorktreesByProject);
@@ -517,6 +692,24 @@ export const SessionSidebar: React.FC<SessionSidebarProps> = ({
 
   const isVSCode = React.useMemo(() => isVSCodeRuntime(), []);
 
+  const openExternal = React.useCallback(async (url: string) => {
+    if (typeof window === 'undefined') return;
+    const tauri = (window as unknown as { __TAURI__?: TauriShell }).__TAURI__;
+    if (tauri?.shell?.open) {
+      try {
+        await tauri.shell.open(url);
+        return;
+      } catch {
+        // fall through
+      }
+    }
+    try {
+      window.open(url, '_blank', 'noopener,noreferrer');
+    } catch {
+      // ignore
+    }
+  }, []);
+
   const flushCollapsedProjectsPersist = React.useCallback(() => {
     if (isVSCode) {
       return;
@@ -627,17 +820,6 @@ export const SessionSidebar: React.FC<SessionSidebarProps> = ({
     };
   }, [projects]);
 
-  const parentMap = React.useMemo(() => {
-    const map = new Map<string, string>();
-    sortedSessions.forEach((session) => {
-      const parentID = (session as Session & { parentID?: string | null }).parentID;
-      if (parentID) {
-        map.set(session.id, parentID);
-      }
-    });
-    return map;
-  }, [sortedSessions]);
-
   const childrenMap = React.useMemo(() => {
     const map = new Map<string, Session[]>();
     sortedSessions.forEach((session) => {
@@ -653,25 +835,6 @@ export const SessionSidebar: React.FC<SessionSidebarProps> = ({
     return map;
   }, [sortedSessions]);
 
-  React.useEffect(() => {
-    if (!currentSessionId) {
-      return;
-    }
-    setExpandedParents((previous) => {
-      const next = new Set(previous);
-      let cursor = parentMap.get(currentSessionId) || null;
-      let changed = false;
-      while (cursor) {
-        if (!next.has(cursor)) {
-          next.add(cursor);
-          changed = true;
-        }
-        cursor = parentMap.get(cursor) || null;
-      }
-      return changed ? next : previous;
-    });
-  }, [currentSessionId, parentMap]);
-
   React.useEffect(() => {
     const directories = new Set<string>();
     sortedSessions.forEach((session) => {
@@ -893,39 +1056,6 @@ export const SessionSidebar: React.FC<SessionSidebarProps> = ({
   const handleDeleteSession = React.useCallback(
     async (session: Session) => {
       const descendants = collectDescendants(session.id);
-      
-      // Check if this is a worktree session - if so, show confirmation dialog
-      const worktree = worktreeMetadata.get(session.id);
-      if (worktree) {
-        // Find ALL sessions linked to this worktree (not just the triggered one)
-        const worktreePath = worktree.path;
-        const allWorktreeSessions: Session[] = [];
-        const sessionIdSet = new Set<string>();
-        
-        // Iterate through all sessions and find those linked to the same worktree
-        sessions.forEach((s) => {
-          const meta = worktreeMetadata.get(s.id);
-          if (meta && meta.path === worktreePath && !sessionIdSet.has(s.id)) {
-            allWorktreeSessions.push(s);
-            sessionIdSet.add(s.id);
-            // Also collect descendants of each worktree session
-            const sessionDescendants = collectDescendants(s.id);
-            sessionDescendants.forEach((desc) => {
-              if (!sessionIdSet.has(desc.id)) {
-                allWorktreeSessions.push(desc);
-                sessionIdSet.add(desc.id);
-              }
-            });
-          }
-        });
-
-        sessionEvents.requestDelete({
-          sessions: allWorktreeSessions,
-          mode: 'worktree',
-          worktree,
-        });
-        return;
-      }
 
       if (descendants.length === 0) {
 
@@ -957,7 +1087,7 @@ export const SessionSidebar: React.FC<SessionSidebarProps> = ({
         }
       }
     },
-    [collectDescendants, deleteSession, deleteSessions, worktreeMetadata, sessions],
+    [collectDescendants, deleteSession, deleteSessions],
   );
 
   const handleOpenDirectoryDialog = React.useCallback(() => {
@@ -1017,7 +1147,13 @@ export const SessionSidebar: React.FC<SessionSidebarProps> = ({
 
 
   const buildGroupedSessions = React.useCallback(
-    (projectSessions: Session[], projectRoot: string | null, availableWorktrees: WorktreeMetadata[]) => {
+    (
+      projectSessions: Session[],
+      projectRoot: string | null,
+      availableWorktrees: WorktreeMetadata[],
+      projectRootBranch: string | null,
+      projectIsRepo: boolean,
+    ) => {
       const normalizedProjectRoot = normalizePath(projectRoot ?? null);
       const sortedProjectSessions = [...projectSessions].sort((a, b) => (b.time?.updated || 0) - (a.time?.updated || 0));
 
@@ -1076,19 +1212,80 @@ export const SessionSidebar: React.FC<SessionSidebarProps> = ({
         return !sessionMap.has(parentID);
       });
 
-      // Build all session nodes into a single flat group sorted by date
-      const allSessions: SessionNode[] = roots.map((session) => buildProjectNode(session));
+      const groupedNodes = new Map<string, SessionNode[]>();
+      const groupOrder = new Map<string, number>();
 
-      // Return single group with all sessions
-      return [{
-        id: 'all',
-        label: 'All sessions',
+      const getGroupKey = (session: Session) => {
+        const metadataPath = normalizePath(worktreeMetadata.get(session.id)?.path ?? null);
+        const sessionDirectory = normalizePath((session as Session & { directory?: string | null }).directory ?? null);
+        const normalizedDir = metadataPath ?? sessionDirectory;
+        if (normalizedDir && normalizedDir !== normalizedProjectRoot && worktreeByPath.has(normalizedDir)) {
+          return normalizedDir;
+        }
+        return normalizedProjectRoot ?? '__project_root__';
+      };
+
+      roots.forEach((session, index) => {
+        const node = buildProjectNode(session);
+        const groupKey = getGroupKey(session);
+        if (!groupedNodes.has(groupKey)) {
+          groupedNodes.set(groupKey, []);
+          groupOrder.set(groupKey, index);
+        }
+        groupedNodes.get(groupKey)?.push(node);
+      });
+
+      const rootKey = normalizedProjectRoot ?? '__project_root__';
+      const groups: SessionGroup[] = [{
+        id: 'root',
+        label: (projectIsRepo && projectRootBranch && projectRootBranch !== 'HEAD')
+          ? `project root: ${projectRootBranch}`
+          : 'project root',
         description: normalizedProjectRoot ? formatPathForDisplay(normalizedProjectRoot, homeDirectory) : null,
         isMain: true,
         worktree: null,
         directory: normalizedProjectRoot,
-        sessions: allSessions,
+        sessions: groupedNodes.get(rootKey) ?? [],
       }];
+
+      const sortedWorktrees = [...availableWorktrees].sort((a, b) => {
+        const aLabel = (a.label || a.branch || a.name || a.path || '').toLowerCase();
+        const bLabel = (b.label || b.branch || b.name || b.path || '').toLowerCase();
+        return aLabel.localeCompare(bLabel);
+      });
+
+      sortedWorktrees.forEach((meta) => {
+        const directory = normalizePath(meta.path) ?? meta.path;
+        const label = meta.branch || meta.name || meta.label || formatDirectoryName(directory, homeDirectory) || directory;
+        groups.push({
+          id: `worktree:${directory}`,
+          label,
+          description: formatPathForDisplay(directory, homeDirectory),
+          isMain: false,
+          worktree: meta,
+          directory,
+          sessions: groupedNodes.get(directory) ?? [],
+        });
+      });
+
+      const represented = new Set(groups.map((group) => group.directory).filter((value): value is string => Boolean(value)));
+      const orphanKeys = Array.from(groupedNodes.keys())
+        .filter((key) => !represented.has(key) && key !== rootKey)
+        .sort((a, b) => (groupOrder.get(a) ?? 0) - (groupOrder.get(b) ?? 0));
+
+      orphanKeys.forEach((directory) => {
+        groups.push({
+          id: `worktree:orphan:${directory}`,
+          label: formatDirectoryName(directory, homeDirectory) || directory,
+          description: formatPathForDisplay(directory, homeDirectory),
+          isMain: false,
+          worktree: null,
+          directory,
+          sessions: groupedNodes.get(directory) ?? [],
+        });
+      });
+
+      return groups;
     },
     [homeDirectory, worktreeMetadata]
   );
@@ -1127,6 +1324,32 @@ export const SessionSidebar: React.FC<SessionSidebarProps> = ({
     });
   }, [isVSCode, safeStorage, scheduleCollapsedProjectsPersist]);
 
+  React.useEffect(() => {
+    try {
+      const serialized = Object.fromEntries(groupOrderByProject.entries());
+      safeStorage.setItem(GROUP_ORDER_STORAGE_KEY, JSON.stringify(serialized));
+    } catch {
+      // ignored
+    }
+  }, [groupOrderByProject, safeStorage]);
+
+  React.useEffect(() => {
+    try {
+      const serialized = Object.fromEntries(activeSessionByProject.entries());
+      safeStorage.setItem(PROJECT_ACTIVE_SESSION_STORAGE_KEY, JSON.stringify(serialized));
+    } catch {
+      // ignored
+    }
+  }, [activeSessionByProject, safeStorage]);
+
+  React.useEffect(() => {
+    try {
+      safeStorage.setItem(GROUP_COLLAPSE_STORAGE_KEY, JSON.stringify(Array.from(collapsedGroups)));
+    } catch {
+      // ignored
+    }
+  }, [collapsedGroups, safeStorage]);
+
   const normalizedProjects = React.useMemo(() => {
     return projects
       .map((project) => ({
@@ -1141,6 +1364,34 @@ export const SessionSidebar: React.FC<SessionSidebarProps> = ({
       }>;
   }, [projects]);
 
+  React.useEffect(() => {
+    let cancelled = false;
+    const run = async () => {
+      const entries = await Promise.all(
+        normalizedProjects.map(async (project) => {
+          const branch = await getRootBranch(project.normalizedPath).catch(() => null);
+          return { id: project.id, branch };
+        }),
+      );
+      if (cancelled) {
+        return;
+      }
+      setProjectRootBranches((prev) => {
+        const next = new Map(prev);
+        entries.forEach(({ id, branch }) => {
+          if (branch) {
+            next.set(id, branch);
+          }
+        });
+        return next;
+      });
+    };
+    void run();
+    return () => {
+      cancelled = true;
+    };
+  }, [normalizedProjects]);
+
   const getSessionsForProject = React.useCallback(
     (project: { normalizedPath: string }) => {
       // In VS Code, only show sessions from the main project directory (skip worktrees)
@@ -1175,13 +1426,424 @@ export const SessionSidebar: React.FC<SessionSidebarProps> = ({
     return normalizedProjects.map((project) => {
       const projectSessions = getSessionsForProject(project);
       const worktreesForProject = availableWorktreesByProject.get(project.normalizedPath) ?? [];
-      const groups = buildGroupedSessions(projectSessions, project.normalizedPath, worktreesForProject);
+      const groups = buildGroupedSessions(
+        projectSessions,
+        project.normalizedPath,
+        worktreesForProject,
+        projectRootBranches.get(project.id) ?? null,
+        Boolean(projectRepoStatus.get(project.id)),
+      );
       return {
         project,
         groups,
       };
     });
-  }, [normalizedProjects, getSessionsForProject, buildGroupedSessions, availableWorktreesByProject]);
+  }, [normalizedProjects, getSessionsForProject, buildGroupedSessions, availableWorktreesByProject, projectRootBranches, projectRepoStatus]);
+
+  const visibleProjectSections = React.useMemo(() => {
+    if (projectSections.length === 0) {
+      return projectSections;
+    }
+    const active = projectSections.find((section) => section.project.id === activeProjectId);
+    return active ? [active] : [projectSections[0]];
+  }, [projectSections, activeProjectId]);
+
+  const activeProjectForHeader = React.useMemo(
+    () => normalizedProjects.find((project) => project.id === activeProjectId) ?? normalizedProjects[0] ?? null,
+    [normalizedProjects, activeProjectId],
+  );
+
+  const activeProjectIsRepo = React.useMemo(
+    () => (activeProjectForHeader ? Boolean(projectRepoStatus.get(activeProjectForHeader.id)) : false),
+    [activeProjectForHeader, projectRepoStatus],
+  );
+  const activeProjectRepoState = React.useMemo(
+    () => (activeProjectForHeader ? projectRepoStatus.get(activeProjectForHeader.id) : undefined),
+    [activeProjectForHeader, projectRepoStatus],
+  );
+  const reserveHeaderActionsSpace = activeProjectRepoState !== false;
+
+  const worktreePrInFlight = React.useRef<Set<string>>(new Set());
+  const visibleWorktreeGroups = React.useMemo(() => {
+    return visibleProjectSections.flatMap((section) =>
+      section.groups
+        .filter((group) => !group.isMain)
+        .map((group) => ({
+          key: `${section.project.id}:${group.id}`,
+          directory: group.directory,
+          label: group.label,
+          worktree: group.worktree,
+        }))
+    );
+  }, [visibleProjectSections]);
+
+  React.useEffect(() => {
+    const validKeys = new Set<string>();
+    projectSections.forEach((section) => {
+      section.groups.forEach((group) => {
+        if (!group.isMain) {
+          validKeys.add(`${section.project.id}:${group.id}`);
+        }
+      });
+    });
+    setWorktreePrByGroupKey((prev) => {
+      if (prev.size === 0) return prev;
+      const next = new Map(prev);
+      let mutated = false;
+      Array.from(next.keys()).forEach((key) => {
+        if (!validKeys.has(key)) {
+          next.delete(key);
+          mutated = true;
+        }
+      });
+      return mutated ? next : prev;
+    });
+    Array.from(worktreePrLastCheckedAtRef.current.keys()).forEach((key) => {
+      if (!validKeys.has(key)) {
+        worktreePrLastCheckedAtRef.current.delete(key);
+      }
+    });
+  }, [projectSections]);
+
+  const ensureWorktreePrLoaded = React.useCallback(async (
+    groupKey: string,
+    directory: string | null,
+    label: string,
+    worktree?: WorktreeMetadata | null,
+    options?: { force?: boolean },
+  ) => {
+    if (!github?.prStatus || !directory || worktreePrInFlight.current.has(groupKey)) {
+      return;
+    }
+    const lastCheckedAt = worktreePrLastCheckedAtRef.current.get(groupKey) ?? 0;
+    const isFresh = Date.now() - lastCheckedAt < PR_REVALIDATE_TTL_MS;
+    if (!options?.force && isFresh) {
+      return;
+    }
+
+    const resolvedBranchFromDirectory = await git.getGitStatus(directory)
+      .then((status) => status?.current ?? '')
+      .catch(() => '');
+    const normalizeBranchCandidate = (value: string) => value
+      .replace(/^refs\/heads\//, '')
+      .replace(/^remotes\//, '')
+      .replace(/^origin\//, '')
+      .trim();
+    const branches = [resolvedBranchFromDirectory, worktree?.branch, worktree?.name, worktree?.label, label]
+      .map((value) => (value || '').trim())
+      .map(normalizeBranchCandidate)
+      .filter((value) => value.length > 0);
+    const uniqueBranches = Array.from(new Set(branches));
+    if (uniqueBranches.length === 0) {
+      worktreePrLastCheckedAtRef.current.set(groupKey, Date.now());
+      return;
+    }
+
+    worktreePrInFlight.current.add(groupKey);
+    try {
+      let matched: GitHubPullRequestStatus | null = null;
+      for (const branch of uniqueBranches) {
+        const status = await github.prStatus(directory, branch);
+        const hasPr = status?.connected !== false && Boolean(status?.pr);
+        if (hasPr) {
+          matched = status;
+          break;
+        }
+      }
+      setWorktreePrByGroupKey((prev) => {
+        const current = prev.get(groupKey);
+        if (!matched) {
+          if (!current) {
+            return prev;
+          }
+          const next = new Map(prev);
+          next.delete(groupKey);
+          return next;
+        }
+
+        const currentPr = current?.pr;
+        const nextPr = matched.pr;
+        const unchanged = Boolean(
+          currentPr
+            && nextPr
+            && currentPr.number === nextPr.number
+            && currentPr.state === nextPr.state
+            && currentPr.draft === nextPr.draft
+            && currentPr.mergeable === nextPr.mergeable
+            && current?.canMerge === matched.canMerge
+            && current?.checks?.state === matched.checks?.state
+            && current?.checks?.failure === matched.checks?.failure
+            && current?.checks?.pending === matched.checks?.pending
+            && current?.checks?.success === matched.checks?.success
+        );
+
+        if (unchanged) {
+          return prev;
+        }
+
+        const next = new Map(prev);
+        next.set(groupKey, matched);
+        return next;
+      });
+    } catch {
+      setWorktreePrByGroupKey((prev) => {
+        if (!prev.has(groupKey)) {
+          return prev;
+        }
+        const next = new Map(prev);
+        next.delete(groupKey);
+        return next;
+      });
+    } finally {
+      worktreePrLastCheckedAtRef.current.set(groupKey, Date.now());
+      worktreePrInFlight.current.delete(groupKey);
+    }
+  }, [github, git]);
+
+  const revalidateVisibleWorktreePrs = React.useCallback(async (options?: { force?: boolean; onlyExistingPr?: boolean }) => {
+    const targetGroups = visibleWorktreeGroups.filter((group) => {
+      if (!group.directory) {
+        return false;
+      }
+      if (options?.onlyExistingPr && !worktreePrByGroupKey.has(group.key)) {
+        return false;
+      }
+      return true;
+    });
+    if (targetGroups.length === 0) {
+      return;
+    }
+
+    let cursor = 0;
+    const workerCount = Math.min(PR_REVALIDATE_CONCURRENCY, targetGroups.length);
+    await Promise.all(
+      Array.from({ length: workerCount }).map(async () => {
+        while (cursor < targetGroups.length) {
+          const index = cursor;
+          cursor += 1;
+          const group = targetGroups[index];
+          await ensureWorktreePrLoaded(group.key, group.directory, group.label, group.worktree, { force: options?.force });
+        }
+      })
+    );
+  }, [visibleWorktreeGroups, worktreePrByGroupKey, ensureWorktreePrLoaded]);
+
+  React.useEffect(() => {
+    if (visibleWorktreeGroups.length === 0) {
+      return;
+    }
+    const timer = window.setTimeout(() => {
+      void revalidateVisibleWorktreePrs();
+    }, 120);
+    return () => {
+      window.clearTimeout(timer);
+    };
+  }, [visibleWorktreeGroups, revalidateVisibleWorktreePrs]);
+
+  React.useEffect(() => {
+    if (!activeProjectId) {
+      return;
+    }
+    void revalidateVisibleWorktreePrs();
+  }, [activeProjectId, revalidateVisibleWorktreePrs]);
+
+  React.useEffect(() => {
+    const onFocus = () => {
+      void revalidateVisibleWorktreePrs();
+    };
+    const onVisibility = () => {
+      if (document.visibilityState === 'visible') {
+        void revalidateVisibleWorktreePrs();
+      }
+    };
+    window.addEventListener('focus', onFocus);
+    document.addEventListener('visibilitychange', onVisibility);
+    return () => {
+      window.removeEventListener('focus', onFocus);
+      document.removeEventListener('visibilitychange', onVisibility);
+    };
+  }, [revalidateVisibleWorktreePrs]);
+
+  React.useEffect(() => {
+    const interval = window.setInterval(() => {
+      if (document.visibilityState !== 'visible') {
+        return;
+      }
+      void revalidateVisibleWorktreePrs({ onlyExistingPr: true });
+    }, PR_REVALIDATE_INTERVAL_MS);
+    return () => {
+      window.clearInterval(interval);
+    };
+  }, [revalidateVisibleWorktreePrs]);
+
+  const projectSessionMeta = React.useMemo(() => {
+    const metaByProject = new Map<string, Map<string, { directory: string | null }>>();
+    const firstSessionByProject = new Map<string, { id: string; directory: string | null }>();
+
+    const visitNodes = (
+      projectId: string,
+      projectRoot: string,
+      fallbackDirectory: string | null,
+      nodes: SessionNode[],
+    ) => {
+      if (!metaByProject.has(projectId)) {
+        metaByProject.set(projectId, new Map());
+      }
+      const projectMap = metaByProject.get(projectId)!;
+      nodes.forEach((node) => {
+        const sessionDirectory = normalizePath(
+          node.worktree?.path
+          ?? (node.session as Session & { directory?: string | null }).directory
+          ?? fallbackDirectory
+          ?? projectRoot,
+        );
+        projectMap.set(node.session.id, { directory: sessionDirectory });
+        if (!firstSessionByProject.has(projectId)) {
+          firstSessionByProject.set(projectId, { id: node.session.id, directory: sessionDirectory });
+        }
+        if (node.children.length > 0) {
+          visitNodes(projectId, projectRoot, sessionDirectory, node.children);
+        }
+      });
+    };
+
+    projectSections.forEach((section) => {
+      section.groups.forEach((group) => {
+        visitNodes(section.project.id, section.project.normalizedPath, group.directory, group.sessions);
+      });
+    });
+
+    return { metaByProject, firstSessionByProject };
+  }, [projectSections]);
+
+  const previousActiveProjectRef = React.useRef<string | null>(null);
+  React.useLayoutEffect(() => {
+    if (!activeProjectId || previousActiveProjectRef.current === activeProjectId) {
+      return;
+    }
+    const section = projectSections.find((item) => item.project.id === activeProjectId);
+    if (!section) {
+      return;
+    }
+    previousActiveProjectRef.current = activeProjectId;
+    const projectMap = projectSessionMeta.metaByProject.get(activeProjectId);
+    if (!projectMap || projectMap.size === 0) {
+      setActiveMainTab('chat');
+      if (mobileVariant) {
+        setSessionSwitcherOpen(false);
+      }
+      openNewSessionDraft({ directoryOverride: section.project.normalizedPath });
+      return;
+    }
+
+    const rememberedSessionId = activeSessionByProject.get(activeProjectId);
+    const remembered = rememberedSessionId && projectMap.has(rememberedSessionId)
+      ? rememberedSessionId
+      : null;
+    const fallback = projectSessionMeta.firstSessionByProject.get(activeProjectId)?.id ?? null;
+    const targetSessionId = remembered ?? fallback;
+    if (!targetSessionId || targetSessionId === currentSessionId) {
+      return;
+    }
+    const targetDirectory = projectMap.get(targetSessionId)?.directory ?? null;
+    handleSessionSelect(targetSessionId, targetDirectory, false, activeProjectId);
+  }, [
+    activeProjectId,
+    activeSessionByProject,
+    currentSessionId,
+    handleSessionSelect,
+    mobileVariant,
+    openNewSessionDraft,
+    projectSections,
+    projectSessionMeta,
+    setActiveMainTab,
+    setSessionSwitcherOpen,
+  ]);
+
+  React.useEffect(() => {
+    if (!activeProjectId || !currentSessionId) {
+      return;
+    }
+    const projectMap = projectSessionMeta.metaByProject.get(activeProjectId);
+    if (!projectMap || !projectMap.has(currentSessionId)) {
+      return;
+    }
+    setActiveSessionByProject((prev) => {
+      if (prev.get(activeProjectId) === currentSessionId) {
+        return prev;
+      }
+      const next = new Map(prev);
+      next.set(activeProjectId, currentSessionId);
+      return next;
+    });
+  }, [activeProjectId, currentSessionId, projectSessionMeta]);
+
+  const currentSessionDirectory = React.useMemo(() => {
+    if (!currentSessionId) {
+      return null;
+    }
+    const metadataPath = worktreeMetadata.get(currentSessionId)?.path;
+    if (metadataPath) {
+      return normalizePath(metadataPath) ?? metadataPath;
+    }
+    const activeSession = sessions.find((session) => session.id === currentSessionId);
+    if (!activeSession) {
+      return null;
+    }
+    return normalizePath((activeSession as Session & { directory?: string | null }).directory ?? null);
+  }, [currentSessionId, sessions, worktreeMetadata]);
+
+  const getOrderedGroups = React.useCallback(
+    (projectId: string, groups: SessionGroup[]) => {
+      const preferredOrder = groupOrderByProject.get(projectId);
+      if (!preferredOrder || preferredOrder.length === 0) {
+        return groups;
+      }
+      const groupById = new Map(groups.map((group) => [group.id, group]));
+      const ordered: SessionGroup[] = [];
+      preferredOrder.forEach((id) => {
+        const group = groupById.get(id);
+        if (group) {
+          ordered.push(group);
+          groupById.delete(id);
+        }
+      });
+      groups.forEach((group) => {
+        if (groupById.has(group.id)) {
+          ordered.push(group);
+        }
+      });
+      return ordered;
+    },
+    [groupOrderByProject],
+  );
+
+  const handleStartInlineProjectRename = React.useCallback(() => {
+    if (!activeProjectForHeader) {
+      return;
+    }
+    setProjectRenameDraft(formatProjectLabel(
+      activeProjectForHeader.label?.trim()
+      || formatDirectoryName(activeProjectForHeader.normalizedPath, homeDirectory)
+      || activeProjectForHeader.normalizedPath,
+    ));
+    setIsProjectRenameInline(true);
+  }, [activeProjectForHeader, homeDirectory]);
+
+  const handleSaveInlineProjectRename = React.useCallback(() => {
+    if (!activeProjectForHeader) {
+      return;
+    }
+    const trimmed = projectRenameDraft.trim();
+    if (!trimmed) {
+      return;
+    }
+    renameProject(activeProjectForHeader.id, trimmed);
+    setIsProjectRenameInline(false);
+  }, [activeProjectForHeader, projectRenameDraft, renameProject]);
+
+  const headerActionButtonClass =
+    'inline-flex h-6 w-6 items-center justify-center rounded-md text-muted-foreground hover:text-foreground hover:bg-interactive-hover/50 focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-primary/50';
 
   // Track when project sticky headers become "stuck"
   React.useEffect(() => {
@@ -1227,8 +1889,23 @@ export const SessionSidebar: React.FC<SessionSidebarProps> = ({
       const sessionTitle = session.title || 'Untitled Session';
       const hasChildren = node.children.length > 0;
       const isExpanded = expandedParents.has(session.id);
-      const additions = session.summary?.additions;
-      const deletions = session.summary?.deletions;
+      const needsAttention = sessionAttentionStates.get(session.id)?.needsAttention === true;
+      const sessionSummary = session.summary as
+        | {
+          additions?: number | string | null;
+          deletions?: number | string | null;
+          diffs?: Array<{ additions?: number | string | null; deletions?: number | string | null }>;
+        }
+        | undefined;
+      const diffTotals = sessionSummary?.diffs?.reduce<{ additions: number; deletions: number }>(
+        (acc, diff) => ({
+          additions: acc.additions + (toFiniteNumber(diff?.additions) ?? 0),
+          deletions: acc.deletions + (toFiniteNumber(diff?.deletions) ?? 0),
+        }),
+        { additions: 0, deletions: 0 },
+      );
+      const additions = toFiniteNumber(sessionSummary?.additions) ?? diffTotals?.additions;
+      const deletions = toFiniteNumber(sessionSummary?.deletions) ?? diffTotals?.deletions;
       const hasSummary = typeof additions === 'number' || typeof deletions === 'number';
 
       if (editingId === session.id) {
@@ -1309,6 +1986,8 @@ export const SessionSidebar: React.FC<SessionSidebarProps> = ({
       const statusType = sessionStatus?.get(session.id)?.type ?? 'idle';
       const isStreaming = statusType === 'busy' || statusType === 'retry';
       const pendingPermissionCount = permissions.get(session.id)?.length ?? 0;
+      const showUnreadStatus = !isStreaming && needsAttention && !isActive;
+      const showStatusMarker = isStreaming || showUnreadStatus;
 
       const streamingIndicator = (() => {
         if (!memoryState) return null;
@@ -1343,8 +2022,26 @@ export const SessionSidebar: React.FC<SessionSidebarProps> = ({
               >
                 {}
                 <div className="flex w-full items-center gap-2 min-w-0 flex-1 overflow-hidden">
-                  {isStreaming ? (
-                    <GridLoader size="xs" className="text-primary flex-shrink-0" />
+                  {showStatusMarker ? (
+                    <span className="inline-flex h-3.5 w-3.5 flex-shrink-0 items-center justify-center">
+                      {isStreaming ? (
+                        <GridLoader size="xs" className="text-primary" />
+                      ) : (
+                        <span className="grid grid-cols-3 gap-[1px] text-[var(--status-info)]" aria-label="Unread updates" title="Unread updates">
+                          {Array.from({ length: 9 }, (_, i) => (
+                            ATTENTION_DIAMOND_INDICES.has(i) ? (
+                              <span
+                                key={i}
+                                className="h-[3px] w-[3px] rounded-full bg-current animate-attention-diamond-pulse"
+                                style={{ animationDelay: getAttentionDiamondDelay(i) }}
+                              />
+                            ) : (
+                              <span key={i} className="h-[3px] w-[3px]" />
+                            )
+                          ))}
+                        </span>
+                      )}
+                    </span>
                   ) : null}
                   <div className="block min-w-0 flex-1 truncate typography-ui-label font-normal text-foreground">
                     {sessionTitle}
@@ -1393,18 +2090,6 @@ export const SessionSidebar: React.FC<SessionSidebarProps> = ({
                   {session.share ? (
                     <RiShare2Line className="h-3 w-3 text-[color:var(--status-info)] flex-shrink-0" />
                   ) : null}
-                  {node.worktree ? (
-                    <Tooltip delayDuration={700}>
-                      <TooltipTrigger asChild>
-                        <span className="flex-shrink-0">
-                          <RiGitBranchLine className="h-3 w-3 text-[color:var(--status-info)]" />
-                        </span>
-                      </TooltipTrigger>
-                      <TooltipContent side="top" className="text-xs">
-                        {node.worktree.branch || node.worktree.label || 'Worktree'}
-                      </TooltipContent>
-                    </Tooltip>
-                  ) : null}
                   {hasSummary && ((additions ?? 0) !== 0 || (deletions ?? 0) !== 0) ? (
                     <span className="flex-shrink-0 text-[0.7rem] leading-none">
                       <span className="text-[color:var(--status-success)]">+{Math.max(0, additions ?? 0)}</span>
@@ -1490,24 +2175,6 @@ export const SessionSidebar: React.FC<SessionSidebarProps> = ({
                         </DropdownMenuItem>
                       </>
                     )}
-                    {node.worktree ? (
-                      <DropdownMenuItem
-                        onClick={() => {
-                          if (projectId && projectId !== activeProjectId) {
-                            setActiveProject(projectId);
-                          }
-                          setActiveMainTab('chat');
-                          if (mobileVariant) {
-                            setSessionSwitcherOpen(false);
-                          }
-                          openNewSessionDraft({ directoryOverride: node.worktree?.path ?? null });
-                        }}
-                        className="[&>svg]:mr-1"
-                      >
-                        <RiGitBranchLine className="mr-1 h-4 w-4" />
-                        New session in worktree
-                      </DropdownMenuItem>
-                    ) : null}
                     <DropdownMenuItem
                       className="text-destructive focus:text-destructive [&>svg]:mr-1"
                       onClick={() => handleDeleteSession(session)}
@@ -1532,6 +2199,7 @@ export const SessionSidebar: React.FC<SessionSidebarProps> = ({
       directoryStatus,
       sessionMemoryState,
       sessionStatus,
+      sessionAttentionStates,
       permissions,
       currentSessionId,
       expandedParents,
@@ -1547,11 +2215,6 @@ export const SessionSidebar: React.FC<SessionSidebarProps> = ({
       handleDeleteSession,
       copiedSessionId,
       mobileVariant,
-      activeProjectId,
-      setActiveProject,
-      setActiveMainTab,
-      setSessionSwitcherOpen,
-      openNewSessionDraft,
       openMenuSessionId,
     ],
   );
@@ -1559,41 +2222,231 @@ export const SessionSidebar: React.FC<SessionSidebarProps> = ({
   const renderGroupSessions = React.useCallback(
     (group: SessionGroup, groupKey: string, projectId?: string | null) => {
       const isExpanded = expandedSessionGroups.has(groupKey);
+      const isCollapsed = collapsedGroups.has(groupKey);
       const maxVisible = hideDirectoryControls ? 10 : 5;
       const totalSessions = group.sessions.length;
       const visibleSessions = isExpanded ? group.sessions : group.sessions.slice(0, maxVisible);
       const remainingCount = totalSessions - visibleSessions.length;
+      const collectGroupSessions = (nodes: SessionNode[]): Session[] => {
+        const collected: Session[] = [];
+        const visit = (list: SessionNode[]) => {
+          list.forEach((node) => {
+            collected.push(node.session);
+            if (node.children.length > 0) {
+              visit(node.children);
+            }
+          });
+        };
+        visit(nodes);
+        return collected;
+      };
+      const allGroupSessions = collectGroupSessions(group.sessions);
+      const normalizedGroupDirectory = normalizePath(group.directory ?? null);
+      const isGitProject = Boolean(projectId && projectRepoStatus.get(projectId));
+      const groupPrStatus = projectId ? worktreePrByGroupKey.get(groupKey) ?? null : null;
+      const groupPr = groupPrStatus?.pr ?? null;
+      const prVisualState = getPrVisualState(groupPrStatus);
+      const prColorVar = prVisualState ? `var(--pr-${prVisualState})` : 'var(--status-info)';
+      const PrStateIcon = prVisualState === 'draft'
+        ? RiGitPrDraftLine
+        : prVisualState === 'merged'
+          ? RiGitMergeLine
+          : prVisualState === 'closed'
+            ? RiGitClosePullRequestLine
+            : RiGitPullRequestLine;
+      const isActiveGroup = Boolean(
+        normalizedGroupDirectory
+          && currentSessionDirectory
+          && normalizedGroupDirectory === currentSessionDirectory,
+      );
 
       return (
-        <>
-          {visibleSessions.map((node) => renderSessionNode(node, 0, group.directory, projectId))}
-          {totalSessions === 0 ? (
-            <div className="py-1 text-left typography-micro text-muted-foreground">
-              No sessions in this workspace yet.
+        <div className="oc-group">
+          <div
+            className="group/gh flex items-center justify-between gap-2 py-1 min-h-8 min-w-0 rounded-sm hover:bg-interactive-hover/50 cursor-pointer"
+            onMouseEnter={() => {
+              if (!group.isMain) {
+                void ensureWorktreePrLoaded(groupKey, group.directory, group.label, group.worktree);
+              }
+            }}
+            onClick={() => {
+              if (!group.isMain) {
+                void ensureWorktreePrLoaded(groupKey, group.directory, group.label, group.worktree);
+              }
+              setCollapsedGroups((prev) => {
+                const next = new Set(prev);
+                if (next.has(groupKey)) {
+                  next.delete(groupKey);
+                } else {
+                  next.add(groupKey);
+                }
+                return next;
+              });
+            }}
+            role="button"
+            tabIndex={0}
+            onKeyDown={(event) => {
+              if (event.key === 'Enter' || event.key === ' ') {
+                event.preventDefault();
+                if (!group.isMain) {
+                  void ensureWorktreePrLoaded(groupKey, group.directory, group.label, group.worktree);
+                }
+                setCollapsedGroups((prev) => {
+                  const next = new Set(prev);
+                  if (next.has(groupKey)) {
+                    next.delete(groupKey);
+                  } else {
+                    next.add(groupKey);
+                  }
+                  return next;
+                });
+              }
+            }}
+            aria-label={isCollapsed ? `Expand ${group.label}` : `Collapse ${group.label}`}
+          >
+            <div className="min-w-0 flex items-center gap-1.5 px-0">
+              {isCollapsed ? (
+                <RiArrowRightSLine className="h-3.5 w-3.5 flex-shrink-0 text-muted-foreground" />
+              ) : (
+                <RiArrowDownSLine className="h-3.5 w-3.5 flex-shrink-0 text-muted-foreground" />
+              )}
+              {!group.isMain || isGitProject ? (
+                !group.isMain && groupPr?.url ? (
+                  <Tooltip>
+                    <TooltipTrigger asChild>
+                      <button
+                        type="button"
+                        onClick={(event) => {
+                          event.stopPropagation();
+                          if (groupPr?.url) {
+                            void openExternal(groupPr.url);
+                          }
+                        }}
+                        className="inline-flex h-4 w-4 items-center justify-center rounded-sm hover:bg-interactive-hover/50"
+                        style={{ color: prColorVar }}
+                        aria-label={getPrTooltipLabel(groupPrStatus)}
+                      >
+                        <PrStateIcon className="h-3.5 w-3.5 flex-shrink-0" />
+                      </button>
+                    </TooltipTrigger>
+                    <TooltipContent side="bottom" sideOffset={4}>
+                      <p>{getPrTooltipLabel(groupPrStatus)}</p>
+                    </TooltipContent>
+                  </Tooltip>
+                ) : (
+                  <RiGitBranchLine className="h-3.5 w-3.5 flex-shrink-0 text-muted-foreground" />
+                )
+              ) : null}
+              <p className={cn('text-[15px] font-semibold truncate', isActiveGroup ? 'text-primary' : 'text-muted-foreground')}>
+                {group.label}
+              </p>
+            </div>
+            {group.directory ? (
+              <div className="flex items-center gap-1 px-0.5">
+                {!group.isMain && group.worktree ? (
+                  <Tooltip>
+                    <TooltipTrigger asChild>
+                      <button
+                        type="button"
+                        onClick={(event) => {
+                          event.stopPropagation();
+                          sessionEvents.requestDelete({
+                            sessions: allGroupSessions,
+                            mode: 'worktree',
+                            worktree: group.worktree,
+                          });
+                        }}
+                        className={cn(
+                          'inline-flex h-6 w-6 items-center justify-center rounded-md text-muted-foreground hover:text-destructive hover:bg-interactive-hover/50 focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-primary/50 transition-opacity',
+                          mobileVariant ? 'opacity-100' : 'opacity-0 group-hover/gh:opacity-100 group-focus-within/gh:opacity-100',
+                        )}
+                        aria-label={`Delete ${group.label}`}
+                      >
+                        <RiDeleteBinLine className="h-4 w-4" />
+                      </button>
+                    </TooltipTrigger>
+                    <TooltipContent side="bottom" sideOffset={4}>
+                      <p>Delete worktree</p>
+                    </TooltipContent>
+                  </Tooltip>
+                ) : null}
+                <Tooltip>
+                  <TooltipTrigger asChild>
+                    <button
+                      type="button"
+                      onClick={(event) => {
+                        event.stopPropagation();
+                        if (projectId && projectId !== activeProjectId) {
+                          setActiveProject(projectId);
+                        }
+                        setActiveMainTab('chat');
+                        if (mobileVariant) {
+                          setSessionSwitcherOpen(false);
+                        }
+                        openNewSessionDraft({ directoryOverride: group.directory });
+                      }}
+                      className="inline-flex h-6 w-6 items-center justify-center rounded-md text-muted-foreground hover:text-foreground hover:bg-interactive-hover/50 focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-primary/50"
+                      aria-label={`New session in ${group.label}`}
+                    >
+                      <RiAddLine className="h-4 w-4" />
+                    </button>
+                  </TooltipTrigger>
+                  <TooltipContent side="bottom" sideOffset={4}>
+                    <p>New session</p>
+                  </TooltipContent>
+                </Tooltip>
+              </div>
+            ) : null}
+          </div>
+          {!isCollapsed ? (
+            <div className="oc-group-body pb-3">
+              {visibleSessions.map((node) => renderSessionNode(node, 0, group.directory, projectId))}
+              {totalSessions === 0 ? (
+                <div className="py-1 text-left typography-micro text-muted-foreground">
+                  No sessions in this workspace yet.
+                </div>
+              ) : null}
+              {remainingCount > 0 && !isExpanded ? (
+                <button
+                  type="button"
+                  onClick={() => toggleGroupSessionLimit(groupKey)}
+                  className="mt-0.5 flex items-center justify-start rounded-md px-1.5 py-0.5 text-left text-xs text-muted-foreground/70 leading-tight hover:text-foreground hover:underline"
+                >
+                  Show {remainingCount} more {remainingCount === 1 ? 'session' : 'sessions'}
+                </button>
+              ) : null}
+              {isExpanded && totalSessions > maxVisible ? (
+                <button
+                  type="button"
+                  onClick={() => toggleGroupSessionLimit(groupKey)}
+                  className="mt-0.5 flex items-center justify-start rounded-md px-1.5 py-0.5 text-left text-xs text-muted-foreground/70 leading-tight hover:text-foreground hover:underline"
+                >
+                  Show fewer sessions
+                </button>
+              ) : null}
             </div>
           ) : null}
-          {remainingCount > 0 && !isExpanded ? (
-            <button
-              type="button"
-              onClick={() => toggleGroupSessionLimit(groupKey)}
-              className="mt-0.5 flex items-center justify-start rounded-md px-1.5 py-0.5 text-left text-xs text-muted-foreground/70 leading-tight hover:text-foreground hover:underline"
-            >
-              Show {remainingCount} more {remainingCount === 1 ? 'session' : 'sessions'}
-            </button>
-          ) : null}
-          {isExpanded && totalSessions > maxVisible ? (
-            <button
-              type="button"
-              onClick={() => toggleGroupSessionLimit(groupKey)}
-              className="mt-0.5 flex items-center justify-start rounded-md px-1.5 py-0.5 text-left text-xs text-muted-foreground/70 leading-tight hover:text-foreground hover:underline"
-            >
-              Show fewer sessions
-            </button>
-          ) : null}
-        </>
+        </div>
       );
     },
-    [expandedSessionGroups, hideDirectoryControls, renderSessionNode, toggleGroupSessionLimit]
+    [
+      expandedSessionGroups,
+      collapsedGroups,
+      hideDirectoryControls,
+      currentSessionDirectory,
+      projectRepoStatus,
+      worktreePrByGroupKey,
+      openExternal,
+      ensureWorktreePrLoaded,
+      renderSessionNode,
+      toggleGroupSessionLimit,
+      activeProjectId,
+      setActiveProject,
+      setActiveMainTab,
+      mobileVariant,
+      setSessionSwitcherOpen,
+      openNewSessionDraft,
+    ]
   );
 
   // DnD sensors for project reordering
@@ -1608,52 +2461,6 @@ export const SessionSidebar: React.FC<SessionSidebarProps> = ({
     })
   );
 
-  const handleDragStart = React.useCallback(
-    (event: DragStartEvent) => {
-      setActiveDragId(event.active.id as string);
-    },
-    []
-  );
-
-  const handleDragEnd = React.useCallback(
-    (event: DragEndEvent) => {
-      const { active, over } = event;
-      setActiveDragId(null);
-      
-      if (!over || active.id === over.id) {
-        return;
-      }
-
-      const oldIndex = normalizedProjects.findIndex((p) => p.id === active.id);
-      const newIndex = normalizedProjects.findIndex((p) => p.id === over.id);
-      if (oldIndex !== -1 && newIndex !== -1) {
-        reorderProjects(oldIndex, newIndex);
-      }
-    },
-    [normalizedProjects, reorderProjects]
-  );
-
-  const handleDragCancel = React.useCallback(() => {
-    setActiveDragId(null);
-  }, []);
-
-  // Get the active dragging project for the overlay
-  const activeDragProject = React.useMemo(() => {
-    if (!activeDragId) return null;
-    const section = projectSections.find((s) => s.project.id === activeDragId);
-    if (!section) return null;
-    const project = section.project;
-    return {
-      id: project.id,
-      label: formatProjectLabel(
-        project.label?.trim()
-          || formatDirectoryName(project.normalizedPath, homeDirectory)
-          || project.normalizedPath
-      ),
-      isActive: project.id === activeProjectId,
-    };
-  }, [activeDragId, projectSections, homeDirectory, activeProjectId]);
-
   return (
     <div
       className={cn(
@@ -1662,14 +2469,104 @@ export const SessionSidebar: React.FC<SessionSidebarProps> = ({
       )}
     >
       {!hideDirectoryControls && (
-        <div className="h-8 select-none pl-3.5 pr-2 flex-shrink-0">
-          <div className="flex h-full items-center justify-between gap-2">
-            <div className="min-w-0 flex items-center gap-2">
-              <p className="typography-ui-label font-medium text-muted-foreground">Projects</p>
-              <span className="typography-micro text-muted-foreground/50">
-                {projects.length}
-              </span>
-            </div>
+        <div className="select-none pl-3.5 pr-2 py-1.5 flex-shrink-0 border-b border-border/60">
+          <div className="flex h-8 items-center justify-between gap-2">
+            <DropdownMenu
+              onOpenChange={(open) => {
+                if (!open) {
+                  setIsProjectRenameInline(false);
+                }
+              }}
+            >
+              <DropdownMenuTrigger asChild>
+                <button
+                  type="button"
+                  className="flex h-8 min-w-0 max-w-[calc(100%-2.5rem)] items-center gap-1 rounded-md px-2 text-left text-foreground hover:bg-interactive-hover/50 focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-primary/50"
+                >
+                  <span className="text-base font-semibold truncate">
+                    {activeProjectForHeader
+                      ? formatProjectLabel(
+                        activeProjectForHeader.label?.trim()
+                        || formatDirectoryName(activeProjectForHeader.normalizedPath, homeDirectory)
+                        || activeProjectForHeader.normalizedPath,
+                      )
+                      : 'Projects'}
+                  </span>
+                  <RiArrowDownSLine className="h-4 w-4 flex-shrink-0 text-muted-foreground" />
+                </button>
+              </DropdownMenuTrigger>
+              <DropdownMenuContent align="start" className="min-w-[220px] max-w-[320px]">
+                {normalizedProjects.map((project) => {
+                  const label = formatProjectLabel(
+                    project.label?.trim()
+                    || formatDirectoryName(project.normalizedPath, homeDirectory)
+                    || project.normalizedPath
+                  );
+                  return (
+                    <DropdownMenuItem
+                      key={project.id}
+                      onClick={() => setActiveProject(project.id)}
+                      className={cn('truncate', project.id === activeProjectId && 'text-primary')}
+                    >
+                      <span className="truncate">{label}</span>
+                    </DropdownMenuItem>
+                  );
+                })}
+                <div className="my-1 h-px bg-border/70" />
+                {!isProjectRenameInline ? (
+                  <DropdownMenuItem
+                    onClick={(event) => {
+                      event.preventDefault();
+                      handleStartInlineProjectRename();
+                    }}
+                    className="gap-2"
+                  >
+                    <RiPencilAiLine className="h-4 w-4" />
+                    Rename project
+                  </DropdownMenuItem>
+                ) : (
+                  <div className="px-2 py-1.5">
+                    <form
+                      className="flex items-center gap-1"
+                      onSubmit={(event) => {
+                        event.preventDefault();
+                        handleSaveInlineProjectRename();
+                      }}
+                    >
+                      <input
+                        value={projectRenameDraft}
+                        onChange={(event) => setProjectRenameDraft(event.target.value)}
+                        className="h-7 flex-1 rounded border border-border bg-transparent px-2 typography-ui-label text-foreground outline-none focus-visible:ring-2 focus-visible:ring-primary/50"
+                        placeholder="Rename project"
+                        autoFocus
+                      />
+                      <button type="submit" className="inline-flex h-7 w-7 items-center justify-center rounded text-muted-foreground hover:text-foreground">
+                        <RiCheckLine className="h-4 w-4" />
+                      </button>
+                      <button
+                        type="button"
+                        onClick={() => setIsProjectRenameInline(false)}
+                        className="inline-flex h-7 w-7 items-center justify-center rounded text-muted-foreground hover:text-foreground"
+                      >
+                        <RiCloseLine className="h-4 w-4" />
+                      </button>
+                    </form>
+                  </div>
+                )}
+                <DropdownMenuItem
+                  onClick={() => {
+                    if (!activeProjectForHeader) {
+                      return;
+                    }
+                    removeProject(activeProjectForHeader.id);
+                  }}
+                  className="text-destructive focus:text-destructive gap-2"
+                >
+                  <RiCloseLine className="h-4 w-4" />
+                  Close project
+                </DropdownMenuItem>
+              </DropdownMenuContent>
+            </DropdownMenu>
             <button
               type="button"
               onClick={handleOpenDirectoryDialog}
@@ -1683,6 +2580,82 @@ export const SessionSidebar: React.FC<SessionSidebarProps> = ({
               <RiFolderAddLine className="h-4.5 w-4.5" />
             </button>
           </div>
+          {reserveHeaderActionsSpace ? (
+            <div className="mt-1 h-8 pl-1">
+              {activeProjectIsRepo ? (
+              <div className="inline-flex h-8 items-center gap-1.5 rounded-md pl-0 pr-1">
+              <Tooltip>
+                <TooltipTrigger asChild>
+                  <button
+                    type="button"
+                    onClick={async () => {
+                      if (!activeProjectForHeader) {
+                        return;
+                      }
+                      if (activeProjectForHeader.id !== activeProjectId) {
+                        setActiveProject(activeProjectForHeader.id);
+                      }
+                      const newWorktreePath = await createWorktreeOnly();
+                      if (!newWorktreePath) {
+                        return;
+                      }
+                      setActiveMainTab('chat');
+                      if (mobileVariant) {
+                        setSessionSwitcherOpen(false);
+                      }
+                      openNewSessionDraft({ directoryOverride: newWorktreePath });
+                    }}
+                    className={headerActionButtonClass}
+                    aria-label="New worktree"
+                  >
+                    <RiGitBranchLine className="h-4.5 w-4.5" />
+                  </button>
+                </TooltipTrigger>
+                <TooltipContent side="bottom" sideOffset={4}><p>New worktree</p></TooltipContent>
+              </Tooltip>
+              <Tooltip>
+                <TooltipTrigger asChild>
+                  <button
+                    type="button"
+                    onClick={() => setIssuePickerOpen(true)}
+                    className={headerActionButtonClass}
+                    aria-label="New from issue"
+                  >
+                    <RiGithubLine className="h-4.5 w-4.5" />
+                  </button>
+                </TooltipTrigger>
+                <TooltipContent side="bottom" sideOffset={4}><p>New from issue</p></TooltipContent>
+              </Tooltip>
+              <Tooltip>
+                <TooltipTrigger asChild>
+                  <button
+                    type="button"
+                    onClick={() => setPullRequestPickerOpen(true)}
+                    className={headerActionButtonClass}
+                    aria-label="New from PR"
+                  >
+                    <RiGitPullRequestLine className="h-4.5 w-4.5" />
+                  </button>
+                </TooltipTrigger>
+                <TooltipContent side="bottom" sideOffset={4}><p>New from PR</p></TooltipContent>
+              </Tooltip>
+              <Tooltip>
+                <TooltipTrigger asChild>
+                  <button
+                    type="button"
+                    onClick={openMultiRunLauncher}
+                    className={headerActionButtonClass}
+                    aria-label="New multi-run"
+                  >
+                    <ArrowsMerge className="h-4.5 w-4.5" />
+                  </button>
+                </TooltipTrigger>
+                <TooltipContent side="bottom" sideOffset={4}><p>New multi-run</p></TooltipContent>
+              </Tooltip>
+              </div>
+              ) : null}
+            </div>
+          ) : null}
         </div>
       )}
 
@@ -1719,18 +2692,8 @@ export const SessionSidebar: React.FC<SessionSidebarProps> = ({
             })()}
           </div>
         ) : (
-          <DndContext
-            sensors={sensors}
-            collisionDetection={closestCenter}
-            onDragStart={handleDragStart}
-            onDragEnd={handleDragEnd}
-            onDragCancel={handleDragCancel}
-          >
-            <SortableContext
-              items={normalizedProjects.map((p) => p.id)}
-              strategy={verticalListSortingStrategy}
-            >
-              {projectSections.map((section) => {
+          <>
+            {visibleProjectSections.map((section) => {
                 const project = section.project;
                 const projectKey = project.id;
                 const projectLabel = formatProjectLabel(
@@ -1739,10 +2702,11 @@ export const SessionSidebar: React.FC<SessionSidebarProps> = ({
                     || project.normalizedPath
                 );
                 const projectDescription = formatPathForDisplay(project.normalizedPath, homeDirectory);
-                const isCollapsed = collapsedProjects.has(projectKey);
+                const isCollapsed = collapsedProjects.has(projectKey) && hideDirectoryControls;
                 const isActiveProject = projectKey === activeProjectId;
                 const isRepo = projectRepoStatus.get(projectKey);
                 const isHovered = hoveredProjectId === projectKey;
+                const orderedGroups = getOrderedGroups(projectKey, section.groups);
 
                 return (
                   <SortableProjectItem
@@ -1810,10 +2774,71 @@ export const SessionSidebar: React.FC<SessionSidebarProps> = ({
                     onClose={() => removeProject(projectKey)}
                     sentinelRef={(el) => { projectHeaderSentinelRefs.current.set(projectKey, el); }}
                     settingsAutoCreateWorktree={settingsAutoCreateWorktree}
+                    showCreateButtons={false}
+                    hideHeader
                   >
                     {!isCollapsed ? (
-                      <div className="space-y-[0.6rem] py-1 pl-1">
-                        {section.groups[0] ? renderGroupSessions(section.groups[0], `${projectKey}:all`, projectKey) : (
+                      <div className="space-y-[0.6rem] py-1">
+                        {section.groups.length > 0 ? (
+                          <DndContext
+                            sensors={sensors}
+                            collisionDetection={closestCenter}
+                            onDragStart={(event) => {
+                              setActiveDraggedGroupId(String(event.active.id));
+                              const width = (event.active.rect.current.initial?.width ?? null);
+                              setActiveDraggedGroupWidth(typeof width === 'number' ? width : null);
+                            }}
+                            onDragCancel={() => {
+                              setActiveDraggedGroupId(null);
+                              setActiveDraggedGroupWidth(null);
+                            }}
+                            onDragEnd={(event) => {
+                              const { active, over } = event;
+                              setActiveDraggedGroupId(null);
+                              setActiveDraggedGroupWidth(null);
+                              if (!over || active.id === over.id) {
+                                return;
+                              }
+                              const oldIndex = orderedGroups.findIndex((item) => item.id === active.id);
+                              const newIndex = orderedGroups.findIndex((item) => item.id === over.id);
+                              if (oldIndex === -1 || newIndex === -1 || oldIndex === newIndex) {
+                                return;
+                              }
+                              const next = arrayMove(orderedGroups, oldIndex, newIndex).map((item) => item.id);
+                              setGroupOrderByProject((prev) => {
+                                const map = new Map(prev);
+                                map.set(projectKey, next);
+                                return map;
+                              });
+                            }}
+                          >
+                            <SortableContext
+                              items={orderedGroups.map((group) => group.id)}
+                              strategy={verticalListSortingStrategy}
+                            >
+                              {orderedGroups.map((group) => {
+                                const groupKey = `${projectKey}:${group.id}`;
+                                return (
+                                  <SortableGroupItem key={group.id} id={group.id}>
+                                    {renderGroupSessions(group, groupKey, projectKey)}
+                                  </SortableGroupItem>
+                                );
+                              })}
+                            </SortableContext>
+                            <DragOverlay modifiers={[centerDragOverlayUnderPointer]} dropAnimation={null}>
+                              {activeDraggedGroupId ? (
+                                (() => {
+                                  const dragGroup = orderedGroups.find((group) => group.id === activeDraggedGroupId);
+                                  if (!dragGroup) {
+                                    return null;
+                                  }
+                                  const showBranchIcon = !dragGroup.isMain || Boolean(isRepo);
+                                  return <GroupDragOverlay label={dragGroup.label} showBranchIcon={showBranchIcon} width={activeDraggedGroupWidth ?? undefined} />;
+                                })()
+                              ) : null}
+                            </DragOverlay>
+                          </DndContext>
+                        ) : (
                           <div className="py-1 text-left typography-micro text-muted-foreground">
                             No sessions yet.
                           </div>
@@ -1823,16 +2848,7 @@ export const SessionSidebar: React.FC<SessionSidebarProps> = ({
                   </SortableProjectItem>
                 );
               })}
-            </SortableContext>
-            <DragOverlay>
-              {activeDragProject ? (
-                <ProjectDragOverlay
-                  projectLabel={activeDragProject.label}
-                  isActiveProject={activeDragProject.isActive}
-                />
-              ) : null}
-            </DragOverlay>
-          </DndContext>
+          </>
         )}
       </ScrollableOverlay>
 
diff --git a/packages/ui/src/components/ui/grid-loader.tsx b/packages/ui/src/components/ui/grid-loader.tsx
index 7dd7d58e..f6db881e 100644
--- a/packages/ui/src/components/ui/grid-loader.tsx
+++ b/packages/ui/src/components/ui/grid-loader.tsx
@@ -13,6 +13,10 @@ const sizeConfig = {
   lg: { container: 'gap-1.5', dot: 'h-2 w-2' },
 };
 
+const getPulseDelayMs = (index: number): number => {
+  return ((index % 3) + Math.floor(index / 3)) * 150;
+};
+
 const GridLoader: React.FC<GridLoaderProps> = ({ className, size = 'md' }) => {
   const config = sizeConfig[size];
 
@@ -25,7 +29,7 @@ const GridLoader: React.FC<GridLoaderProps> = ({ className, size = 'md' }) => {
         <div
           key={i}
           className={cn('rounded-full bg-current animate-grid-pulse', config.dot)}
-          style={{ animationDelay: `${((i % 3) + Math.floor(i / 3)) * 150}ms` }}
+          style={{ animationDelay: `${getPulseDelayMs(i)}ms` }}
         />
       ))}
     </div>
diff --git a/packages/ui/src/index.css b/packages/ui/src/index.css
index 77fc4425..4d31ca7a 100644
--- a/packages/ui/src/index.css
+++ b/packages/ui/src/index.css
@@ -802,6 +802,19 @@ textarea[data-terminal-hidden-input="true"]::placeholder {
   animation: grid-pulse 1.2s ease-in-out infinite;
 }
 
+@keyframes attention-diamond-pulse {
+  0%, 100% {
+    opacity: 0.52;
+  }
+  50% {
+    opacity: 0.92;
+  }
+}
+
+.animate-attention-diamond-pulse {
+  animation: attention-diamond-pulse 2.3s ease-in-out infinite;
+}
+
 @keyframes marquee-scroll {
   0% { transform: translateX(0); }
   100% { transform: translateX(-100%); }
@@ -828,4 +841,9 @@ textarea[data-terminal-hidden-input="true"]::placeholder {
   .marquee-text--active:hover {
     animation: none;
   }
+
+  .animate-grid-pulse,
+  .animate-attention-diamond-pulse {
+    animation: none;
+  }
 }
diff --git a/packages/ui/src/lib/theme/cssGenerator.ts b/packages/ui/src/lib/theme/cssGenerator.ts
index a2701ae7..7d4129d3 100644
--- a/packages/ui/src/lib/theme/cssGenerator.ts
+++ b/packages/ui/src/lib/theme/cssGenerator.ts
@@ -49,6 +49,7 @@ export class CSSVariableGenerator {
     cssVars.push(...this.generateSurfaceColors(theme.colors.surface));
     cssVars.push(...this.generateInteractiveColors(theme.colors.interactive));
     cssVars.push(...this.generateStatusColors(theme.colors.status));
+    cssVars.push(...this.generatePullRequestColors(theme));
 
     cssVars.push(...this.generateSyntaxColors(theme.colors.syntax));
 
@@ -256,6 +257,17 @@ export class CSSVariableGenerator {
     return vars;
   }
 
+  private generatePullRequestColors(theme: Theme): string[] {
+    const vars: string[] = [];
+    const pr = theme.colors.pr;
+    vars.push(`  --pr-open: ${pr?.open || theme.colors.status.success};`);
+    vars.push(`  --pr-draft: ${pr?.draft || theme.colors.surface.mutedForeground};`);
+    vars.push(`  --pr-blocked: ${pr?.blocked || theme.colors.status.warning};`);
+    vars.push(`  --pr-merged: ${pr?.merged || (theme.metadata.variant === 'dark' ? '#8957e5' : '#8250df')};`);
+    vars.push(`  --pr-closed: ${pr?.closed || theme.colors.status.error};`);
+    return vars;
+  }
+
   private generateSyntaxColors(syntax: Theme['colors']['syntax']): string[] {
     const vars: string[] = [];
 
diff --git a/packages/ui/src/lib/theme/themes/aura-dark.json b/packages/ui/src/lib/theme/themes/aura-dark.json
index f2e79cc6..b87e58b0 100644
--- a/packages/ui/src/lib/theme/themes/aura-dark.json
+++ b/packages/ui/src/lib/theme/themes/aura-dark.json
@@ -56,6 +56,13 @@
       "infoBackground": "#82E2FF20",
       "infoBorder": "#82E2FF50"
     },
+    "pr": {
+      "open": "#61FFCA",
+      "draft": "#6D6D6D",
+      "blocked": "#FFCA85",
+      "merged": "#A277FF",
+      "closed": "#FF6767"
+    },
     "syntax": {
       "base": {
         "background": "#1A1921",
diff --git a/packages/ui/src/lib/theme/themes/aura-light.json b/packages/ui/src/lib/theme/themes/aura-light.json
index 4339f5b3..08816294 100644
--- a/packages/ui/src/lib/theme/themes/aura-light.json
+++ b/packages/ui/src/lib/theme/themes/aura-light.json
@@ -56,6 +56,13 @@
       "infoBackground": "#5BB8D920",
       "infoBorder": "#5BB8D950"
     },
+    "pr": {
+      "open": "#40BF7A",
+      "draft": "#6D6D6D",
+      "blocked": "#D9A24A",
+      "merged": "#A277FF",
+      "closed": "#D94F4F"
+    },
     "syntax": {
       "base": {
         "background": "#EFE8FC",
diff --git a/packages/ui/src/lib/theme/themes/ayu-dark.json b/packages/ui/src/lib/theme/themes/ayu-dark.json
index f3e67953..bdcdaf6f 100644
--- a/packages/ui/src/lib/theme/themes/ayu-dark.json
+++ b/packages/ui/src/lib/theme/themes/ayu-dark.json
@@ -56,6 +56,13 @@
       "infoBackground": "#66C6F120",
       "infoBorder": "#66C6F150"
     },
+    "pr": {
+      "open": "#78D05C",
+      "draft": "#A3ADBA",
+      "blocked": "#E4A75C",
+      "merged": "#8a44f2",
+      "closed": "#F58572"
+    },
     "syntax": {
       "base": {
         "background": "#18222C",
diff --git a/packages/ui/src/lib/theme/themes/ayu-light.json b/packages/ui/src/lib/theme/themes/ayu-light.json
index 8342cc32..18e03d6a 100644
--- a/packages/ui/src/lib/theme/themes/ayu-light.json
+++ b/packages/ui/src/lib/theme/themes/ayu-light.json
@@ -56,6 +56,13 @@
       "infoBackground": "#2F9BCE20",
       "infoBorder": "#2F9BCE50"
     },
+    "pr": {
+      "open": "#5FB978",
+      "draft": "#77818D",
+      "blocked": "#EA9F41",
+      "merged": "#7b3cda",
+      "closed": "#E6656A"
+    },
     "syntax": {
       "base": {
         "background": "#FCF9F3",
diff --git a/packages/ui/src/lib/theme/themes/carbonfox-dark.json b/packages/ui/src/lib/theme/themes/carbonfox-dark.json
index 2cfeb243..17002b6b 100644
--- a/packages/ui/src/lib/theme/themes/carbonfox-dark.json
+++ b/packages/ui/src/lib/theme/themes/carbonfox-dark.json
@@ -56,6 +56,13 @@
       "infoBackground": "#78A9FF20",
       "infoBorder": "#78A9FF50"
     },
+    "pr": {
+      "open": "#42BE65",
+      "draft": "#8D8D8D",
+      "blocked": "#F1C21B",
+      "merged": "#BE95FF",
+      "closed": "#FF8389"
+    },
     "syntax": {
       "base": {
         "background": "#262626",
diff --git a/packages/ui/src/lib/theme/themes/carbonfox-light.json b/packages/ui/src/lib/theme/themes/carbonfox-light.json
index 064c56bd..5f0faa0a 100644
--- a/packages/ui/src/lib/theme/themes/carbonfox-light.json
+++ b/packages/ui/src/lib/theme/themes/carbonfox-light.json
@@ -56,6 +56,13 @@
       "infoBackground": "#0043CE20",
       "infoBorder": "#0043CE50"
     },
+    "pr": {
+      "open": "#42BE65",
+      "draft": "#8D8D8D",
+      "blocked": "#F1C21B",
+      "merged": "#BE95FF",
+      "closed": "#FF8389"
+    },
     "syntax": {
       "base": {
         "background": "#F4F4F4",
diff --git a/packages/ui/src/lib/theme/themes/catppuccin-dark.json b/packages/ui/src/lib/theme/themes/catppuccin-dark.json
index 134d03c3..4a3e3810 100644
--- a/packages/ui/src/lib/theme/themes/catppuccin-dark.json
+++ b/packages/ui/src/lib/theme/themes/catppuccin-dark.json
@@ -56,6 +56,13 @@
       "infoBackground": "#89DCEB20",
       "infoBorder": "#89DCEB50"
     },
+    "pr": {
+      "open": "#A6D189",
+      "draft": "#A6ADC8",
+      "blocked": "#F9E2AF",
+      "merged": "#d8b4fe",
+      "closed": "#F38BA8"
+    },
     "syntax": {
       "base": {
         "background": "#211F31",
diff --git a/packages/ui/src/lib/theme/themes/catppuccin-light.json b/packages/ui/src/lib/theme/themes/catppuccin-light.json
index bb865048..93c6f09e 100644
--- a/packages/ui/src/lib/theme/themes/catppuccin-light.json
+++ b/packages/ui/src/lib/theme/themes/catppuccin-light.json
@@ -56,6 +56,13 @@
       "infoBackground": "#04A5E520",
       "infoBorder": "#04A5E550"
     },
+    "pr": {
+      "open": "#40A02B",
+      "draft": "#6C6F85",
+      "blocked": "#DF8E1D",
+      "merged": "#9572fd",
+      "closed": "#D20F39"
+    },
     "syntax": {
       "base": {
         "background": "#F2D8D4",
diff --git a/packages/ui/src/lib/theme/themes/dracula-dark.json b/packages/ui/src/lib/theme/themes/dracula-dark.json
index 5784ab4a..1b2cbfb7 100644
--- a/packages/ui/src/lib/theme/themes/dracula-dark.json
+++ b/packages/ui/src/lib/theme/themes/dracula-dark.json
@@ -56,6 +56,13 @@
       "infoBackground": "#8BE9FD20",
       "infoBorder": "#8BE9FD50"
     },
+    "pr": {
+      "open": "#50FA7B",
+      "draft": "#B6B9E4",
+      "blocked": "#FFB86C",
+      "merged": "#BD93F9",
+      "closed": "#FF5555"
+    },
     "syntax": {
       "base": {
         "background": "#181926",
diff --git a/packages/ui/src/lib/theme/themes/dracula-light.json b/packages/ui/src/lib/theme/themes/dracula-light.json
index bf95f5c1..44106ab6 100644
--- a/packages/ui/src/lib/theme/themes/dracula-light.json
+++ b/packages/ui/src/lib/theme/themes/dracula-light.json
@@ -56,6 +56,13 @@
       "infoBackground": "#1D7FC520",
       "infoBorder": "#1D7FC550"
     },
+    "pr": {
+      "open": "#2FBF71",
+      "draft": "#52526B",
+      "blocked": "#F7A14D",
+      "merged": "#7C6BF5",
+      "closed": "#D9536F"
+    },
     "syntax": {
       "base": {
         "background": "#F1F2ED",
diff --git a/packages/ui/src/lib/theme/themes/flexoki-dark.json b/packages/ui/src/lib/theme/themes/flexoki-dark.json
index 3de7d684..3706a839 100644
--- a/packages/ui/src/lib/theme/themes/flexoki-dark.json
+++ b/packages/ui/src/lib/theme/themes/flexoki-dark.json
@@ -56,6 +56,13 @@
       "infoBackground": "#205EA620",
       "infoBorder": "#205EA650"
     },
+    "pr": {
+      "open": "#A0AF54",
+      "draft": "#878580",
+      "blocked": "#DA702C",
+      "merged": "#8B7EC8",
+      "closed": "#D14D41"
+    },
     "syntax": {
       "base": {
         "background": "#1C1B1A",
diff --git a/packages/ui/src/lib/theme/themes/flexoki-light.json b/packages/ui/src/lib/theme/themes/flexoki-light.json
index 171ac6ac..7d46942c 100644
--- a/packages/ui/src/lib/theme/themes/flexoki-light.json
+++ b/packages/ui/src/lib/theme/themes/flexoki-light.json
@@ -56,6 +56,13 @@
       "infoBackground": "#4385BE20",
       "infoBorder": "#4385BE50"
     },
+    "pr": {
+      "open": "#66800B",
+      "draft": "#6F6E69",
+      "blocked": "#BC5215",
+      "merged": "#5E409D",
+      "closed": "#AF3029"
+    },
     "syntax": {
       "base": {
         "background": "#F2F0E5",
diff --git a/packages/ui/src/lib/theme/themes/gruvbox-dark.json b/packages/ui/src/lib/theme/themes/gruvbox-dark.json
index 2a8032ec..5c09602d 100644
--- a/packages/ui/src/lib/theme/themes/gruvbox-dark.json
+++ b/packages/ui/src/lib/theme/themes/gruvbox-dark.json
@@ -56,6 +56,13 @@
       "infoBackground": "#D3869B20",
       "infoBorder": "#D3869B50"
     },
+    "pr": {
+      "open": "#B8BB26",
+      "draft": "#A89984",
+      "blocked": "#FABD2F",
+      "merged": "#8973a8",
+      "closed": "#FB4934"
+    },
     "syntax": {
       "base": {
         "background": "#32302F",
diff --git a/packages/ui/src/lib/theme/themes/gruvbox-light.json b/packages/ui/src/lib/theme/themes/gruvbox-light.json
index a10822fd..25f78074 100644
--- a/packages/ui/src/lib/theme/themes/gruvbox-light.json
+++ b/packages/ui/src/lib/theme/themes/gruvbox-light.json
@@ -56,6 +56,13 @@
       "infoBackground": "#8F3F7120",
       "infoBorder": "#8F3F7150"
     },
+    "pr": {
+      "open": "#79740E",
+      "draft": "#7C6F64",
+      "blocked": "#B57614",
+      "merged": "#5e4c76",
+      "closed": "#9D0006"
+    },
     "syntax": {
       "base": {
         "background": "#F2E5BC",
diff --git a/packages/ui/src/lib/theme/themes/index.ts b/packages/ui/src/lib/theme/themes/index.ts
index 44a98cb9..980a2770 100644
--- a/packages/ui/src/lib/theme/themes/index.ts
+++ b/packages/ui/src/lib/theme/themes/index.ts
@@ -1,10 +1,11 @@
 import type { Theme } from '@/types/theme';
 import { presetThemes } from './presets';
+import { withPrColors } from './prColors';
 import flexokiLightRaw from './flexoki-light.json';
 import flexokiDarkRaw from './flexoki-dark.json';
 
-export const flexokiLightTheme = flexokiLightRaw as Theme;
-export const flexokiDarkTheme = flexokiDarkRaw as Theme;
+export const flexokiLightTheme = withPrColors(flexokiLightRaw as Theme);
+export const flexokiDarkTheme = withPrColors(flexokiDarkRaw as Theme);
 
 export const DEFAULT_LIGHT_THEME_ID = 'flexoki-light' as const;
 export const DEFAULT_DARK_THEME_ID = 'flexoki-dark' as const;
diff --git a/packages/ui/src/lib/theme/themes/kanagawa-dark.json b/packages/ui/src/lib/theme/themes/kanagawa-dark.json
index dc2f6630..f194352c 100644
--- a/packages/ui/src/lib/theme/themes/kanagawa-dark.json
+++ b/packages/ui/src/lib/theme/themes/kanagawa-dark.json
@@ -56,6 +56,13 @@
       "infoBackground": "#7E9CD820",
       "infoBorder": "#7E9CD850"
     },
+    "pr": {
+      "open": "#98BB6C",
+      "draft": "#54546D",
+      "blocked": "#FF9E3B",
+      "merged": "#957FB8",
+      "closed": "#E82424"
+    },
     "syntax": {
       "base": {
         "background": "#16161D",
diff --git a/packages/ui/src/lib/theme/themes/kanagawa-light.json b/packages/ui/src/lib/theme/themes/kanagawa-light.json
index 18af2119..e1e6a5fe 100644
--- a/packages/ui/src/lib/theme/themes/kanagawa-light.json
+++ b/packages/ui/src/lib/theme/themes/kanagawa-light.json
@@ -56,6 +56,13 @@
       "infoBackground": "#6693BF20",
       "infoBorder": "#4D699B50"
     },
+    "pr": {
+      "open": "#6F894E",
+      "draft": "#716E61",
+      "blocked": "#DE9800",
+      "merged": "#624C83",
+      "closed": "#E82424"
+    },
     "syntax": {
       "base": {
         "background": "#DCD5AC",
diff --git a/packages/ui/src/lib/theme/themes/mono-dark.json b/packages/ui/src/lib/theme/themes/mono-dark.json
index f772ff2e..d91f770e 100644
--- a/packages/ui/src/lib/theme/themes/mono-dark.json
+++ b/packages/ui/src/lib/theme/themes/mono-dark.json
@@ -56,6 +56,13 @@
       "infoBackground": "#ffffff14",
       "infoBorder": "#ffffff28"
     },
+    "pr": {
+      "open": "#E5E5E5",
+      "draft": "#B3B3B3",
+      "blocked": "#999999",
+      "merged": "#CCCCCC",
+      "closed": "#666666"
+    },
     "syntax": {
       "base": {
         "background": "#0A0A0A",
diff --git a/packages/ui/src/lib/theme/themes/mono-light.json b/packages/ui/src/lib/theme/themes/mono-light.json
index 00db54db..8d618552 100644
--- a/packages/ui/src/lib/theme/themes/mono-light.json
+++ b/packages/ui/src/lib/theme/themes/mono-light.json
@@ -56,6 +56,13 @@
       "infoBackground": "#0000000c",
       "infoBorder": "#0000001a"
     },
+    "pr": {
+      "open": "#1A1A1A",
+      "draft": "#4D4D4D",
+      "blocked": "#999999",
+      "merged": "#333333",
+      "closed": "#666666"
+    },
     "syntax": {
       "base": {
         "background": "#F5F5F5",
diff --git a/packages/ui/src/lib/theme/themes/mono-plus-dark.json b/packages/ui/src/lib/theme/themes/mono-plus-dark.json
index 609fd743..3e245c79 100644
--- a/packages/ui/src/lib/theme/themes/mono-plus-dark.json
+++ b/packages/ui/src/lib/theme/themes/mono-plus-dark.json
@@ -56,6 +56,13 @@
       "infoBackground": "#6a7e9e20",
       "infoBorder": "#6a7e9e50"
     },
+    "pr": {
+      "open": "#6a8e6a",
+      "draft": "#8c8c8c",
+      "blocked": "#9e8a6a",
+      "merged": "#bda2e8",
+      "closed": "#9e6a6a"
+    },
     "syntax": {
       "base": {
         "background": "#0a0a0a",
diff --git a/packages/ui/src/lib/theme/themes/mono-plus-light.json b/packages/ui/src/lib/theme/themes/mono-plus-light.json
index a1486850..9af4d0e7 100644
--- a/packages/ui/src/lib/theme/themes/mono-plus-light.json
+++ b/packages/ui/src/lib/theme/themes/mono-plus-light.json
@@ -56,6 +56,13 @@
       "infoBackground": "#5a6a8a18",
       "infoBorder": "#5a6a8a40"
     },
+    "pr": {
+      "open": "#6a8e6a",
+      "draft": "#8c8c8c",
+      "blocked": "#8a7a5a",
+      "merged": "#8769b6",
+      "closed": "#8a5a5a"
+    },
     "syntax": {
       "base": {
         "background": "#f5f5f5",
diff --git a/packages/ui/src/lib/theme/themes/monokai-dark.json b/packages/ui/src/lib/theme/themes/monokai-dark.json
index e37a8c61..56578de7 100644
--- a/packages/ui/src/lib/theme/themes/monokai-dark.json
+++ b/packages/ui/src/lib/theme/themes/monokai-dark.json
@@ -56,6 +56,13 @@
       "infoBackground": "#66D9EF20",
       "infoBorder": "#66D9EF50"
     },
+    "pr": {
+      "open": "#A6E22E",
+      "draft": "#C5C5C0",
+      "blocked": "#FD971F",
+      "merged": "#AE81FF",
+      "closed": "#F92672"
+    },
     "syntax": {
       "base": {
         "background": "#27281F",
diff --git a/packages/ui/src/lib/theme/themes/monokai-light.json b/packages/ui/src/lib/theme/themes/monokai-light.json
index 2dd67330..ee955fd7 100644
--- a/packages/ui/src/lib/theme/themes/monokai-light.json
+++ b/packages/ui/src/lib/theme/themes/monokai-light.json
@@ -56,6 +56,13 @@
       "infoBackground": "#2D9AD720",
       "infoBorder": "#2D9AD750"
     },
+    "pr": {
+      "open": "#4FB54B",
+      "draft": "#6D5C40",
+      "blocked": "#F1A948",
+      "merged": "#BF7BFF",
+      "closed": "#E54B4B"
+    },
     "syntax": {
       "base": {
         "background": "#F8F2E6",
diff --git a/packages/ui/src/lib/theme/themes/nightowl-dark.json b/packages/ui/src/lib/theme/themes/nightowl-dark.json
index d4e5423f..e75e3f2a 100644
--- a/packages/ui/src/lib/theme/themes/nightowl-dark.json
+++ b/packages/ui/src/lib/theme/themes/nightowl-dark.json
@@ -56,6 +56,13 @@
       "infoBackground": "#82AAFF20",
       "infoBorder": "#82AAFF50"
     },
+    "pr": {
+      "open": "#C5E478",
+      "draft": "#5F7E97",
+      "blocked": "#ECC48D",
+      "merged": "#BC82FF",
+      "closed": "#EF5350"
+    },
     "syntax": {
       "base": {
         "background": "#0B253A",
diff --git a/packages/ui/src/lib/theme/themes/nightowl-light.json b/packages/ui/src/lib/theme/themes/nightowl-light.json
index e9569e1d..1d99df00 100644
--- a/packages/ui/src/lib/theme/themes/nightowl-light.json
+++ b/packages/ui/src/lib/theme/themes/nightowl-light.json
@@ -56,6 +56,13 @@
       "infoBackground": "#4876D620",
       "infoBorder": "#4876D650"
     },
+    "pr": {
+      "open": "#2AA298",
+      "draft": "#7A8181",
+      "blocked": "#c98f65",
+      "merged": "#994CC3",
+      "closed": "#DE3D3B"
+    },
     "syntax": {
       "base": {
         "background": "#F0F0F0",
diff --git a/packages/ui/src/lib/theme/themes/nord-dark.json b/packages/ui/src/lib/theme/themes/nord-dark.json
index 017a62fa..8c0594cf 100644
--- a/packages/ui/src/lib/theme/themes/nord-dark.json
+++ b/packages/ui/src/lib/theme/themes/nord-dark.json
@@ -56,6 +56,13 @@
       "infoBackground": "#81A1C120",
       "infoBorder": "#81A1C150"
     },
+    "pr": {
+      "open": "#A3BE8C",
+      "draft": "#A4ADBF",
+      "blocked": "#D08770",
+      "merged": "#b788d0",
+      "closed": "#BF616A"
+    },
     "syntax": {
       "base": {
         "background": "#222938",
diff --git a/packages/ui/src/lib/theme/themes/nord-light.json b/packages/ui/src/lib/theme/themes/nord-light.json
index 2d968142..f7e0b980 100644
--- a/packages/ui/src/lib/theme/themes/nord-light.json
+++ b/packages/ui/src/lib/theme/themes/nord-light.json
@@ -56,6 +56,13 @@
       "infoBackground": "#81A1C120",
       "infoBorder": "#81A1C150"
     },
+    "pr": {
+      "open": "#8FBCBB",
+      "draft": "#4C566A",
+      "blocked": "#D08770",
+      "merged": "#9b5eac",
+      "closed": "#BF616A"
+    },
     "syntax": {
       "base": {
         "background": "#E4E8F0",
diff --git a/packages/ui/src/lib/theme/themes/onedarkpro-dark.json b/packages/ui/src/lib/theme/themes/onedarkpro-dark.json
index 5de05438..923b5364 100644
--- a/packages/ui/src/lib/theme/themes/onedarkpro-dark.json
+++ b/packages/ui/src/lib/theme/themes/onedarkpro-dark.json
@@ -56,6 +56,13 @@
       "infoBackground": "#56B6C220",
       "infoBorder": "#56B6C250"
     },
+    "pr": {
+      "open": "#98C379",
+      "draft": "#818899",
+      "blocked": "#E5C07B",
+      "merged": "#bb61ef",
+      "closed": "#E06C75"
+    },
     "syntax": {
       "base": {
         "background": "#212631",
diff --git a/packages/ui/src/lib/theme/themes/onedarkpro-light.json b/packages/ui/src/lib/theme/themes/onedarkpro-light.json
index d433c078..7a47e2ab 100644
--- a/packages/ui/src/lib/theme/themes/onedarkpro-light.json
+++ b/packages/ui/src/lib/theme/themes/onedarkpro-light.json
@@ -56,6 +56,13 @@
       "infoBackground": "#61AFEF20",
       "infoBorder": "#61AFEF50"
     },
+    "pr": {
+      "open": "#4FA66D",
+      "draft": "#6B717F",
+      "blocked": "#D19A66",
+      "merged": "#a052ff",
+      "closed": "#E06C75"
+    },
     "syntax": {
       "base": {
         "background": "#EEF0F4",
diff --git a/packages/ui/src/lib/theme/themes/prColors.ts b/packages/ui/src/lib/theme/themes/prColors.ts
new file mode 100644
index 00000000..b3aa2893
--- /dev/null
+++ b/packages/ui/src/lib/theme/themes/prColors.ts
@@ -0,0 +1,39 @@
+import type { Theme } from '@/types/theme';
+
+const DEFAULT_MERGED_DARK = '#8957e5';
+const DEFAULT_MERGED_LIGHT = '#8250df';
+
+const pickMergedColor = (theme: Theme): string => {
+  const tokens = theme.colors.syntax?.tokens ?? {};
+  const candidates = [
+    tokens.className,
+    tokens.enum,
+    tokens.variableGlobal,
+    theme.colors.syntax?.base?.keyword,
+  ].filter((value): value is string => typeof value === 'string' && value.trim().length > 0);
+
+  if (candidates.length > 0) {
+    return candidates[0];
+  }
+  return theme.metadata.variant === 'dark' ? DEFAULT_MERGED_DARK : DEFAULT_MERGED_LIGHT;
+};
+
+export const withPrColors = (theme: Theme): Theme => {
+  if (theme.colors.pr) {
+    return theme;
+  }
+
+  return {
+    ...theme,
+    colors: {
+      ...theme.colors,
+      pr: {
+        open: theme.colors.status.success,
+        draft: theme.colors.surface.mutedForeground,
+        blocked: theme.colors.status.warning,
+        merged: pickMergedColor(theme),
+        closed: theme.colors.status.error,
+      },
+    },
+  };
+};
diff --git a/packages/ui/src/lib/theme/themes/presets.ts b/packages/ui/src/lib/theme/themes/presets.ts
index 479f0824..44c22414 100644
--- a/packages/ui/src/lib/theme/themes/presets.ts
+++ b/packages/ui/src/lib/theme/themes/presets.ts
@@ -1,4 +1,5 @@
 import type { Theme } from '@/types/theme';
+import { withPrColors } from './prColors';
 
 import aura_dark_Raw from './aura-dark.json';
 import aura_light_Raw from './aura-light.json';
@@ -70,4 +71,4 @@ export const presetThemes: Theme[] = [
   mono_light_Raw as Theme,
   vitesse_dark_dark_Raw as Theme,
   vitesse_light_light_Raw as Theme,
-];
+].map((theme) => withPrColors(theme));
diff --git a/packages/ui/src/lib/theme/themes/solarized-dark.json b/packages/ui/src/lib/theme/themes/solarized-dark.json
index f77a5a70..f3ffb65d 100644
--- a/packages/ui/src/lib/theme/themes/solarized-dark.json
+++ b/packages/ui/src/lib/theme/themes/solarized-dark.json
@@ -56,6 +56,13 @@
       "infoBackground": "#2AA19820",
       "infoBorder": "#2AA19850"
     },
+    "pr": {
+      "open": "#859900",
+      "draft": "#6C7F80",
+      "blocked": "#B58900",
+      "merged": "#7f6cc4",
+      "closed": "#DC322F"
+    },
     "syntax": {
       "base": {
         "background": "#022733",
diff --git a/packages/ui/src/lib/theme/themes/solarized-light.json b/packages/ui/src/lib/theme/themes/solarized-light.json
index a3f5ee06..9ec16dc0 100644
--- a/packages/ui/src/lib/theme/themes/solarized-light.json
+++ b/packages/ui/src/lib/theme/themes/solarized-light.json
@@ -56,6 +56,13 @@
       "infoBackground": "#2AA19820",
       "infoBorder": "#2AA19850"
     },
+    "pr": {
+      "open": "#859900",
+      "draft": "#7A8C8E",
+      "blocked": "#B58900",
+      "merged": "#6e26d2",
+      "closed": "#DC322F"
+    },
     "syntax": {
       "base": {
         "background": "#F6EFDA",
diff --git a/packages/ui/src/lib/theme/themes/tokyonight-dark.json b/packages/ui/src/lib/theme/themes/tokyonight-dark.json
index 411d36c2..68279b4d 100644
--- a/packages/ui/src/lib/theme/themes/tokyonight-dark.json
+++ b/packages/ui/src/lib/theme/themes/tokyonight-dark.json
@@ -56,6 +56,13 @@
       "infoBackground": "#7DCFFF20",
       "infoBorder": "#7DCFFF50"
     },
+    "pr": {
+      "open": "#9ECE6A",
+      "draft": "#7A88CF",
+      "blocked": "#E0AF68",
+      "merged": "#BB9AF7",
+      "closed": "#F7768E"
+    },
     "syntax": {
       "base": {
         "background": "#111428",
diff --git a/packages/ui/src/lib/theme/themes/tokyonight-light.json b/packages/ui/src/lib/theme/themes/tokyonight-light.json
index c7eee71f..7c4fefe3 100644
--- a/packages/ui/src/lib/theme/themes/tokyonight-light.json
+++ b/packages/ui/src/lib/theme/themes/tokyonight-light.json
@@ -56,6 +56,13 @@
       "infoBackground": "#00719720",
       "infoBorder": "#00719750"
     },
+    "pr": {
+      "open": "#587539",
+      "draft": "#5C6390",
+      "blocked": "#8C6C3E",
+      "merged": "#9854F1",
+      "closed": "#C94060"
+    },
     "syntax": {
       "base": {
         "background": "#DEE0EA",
diff --git a/packages/ui/src/lib/theme/themes/vesper-dark.json b/packages/ui/src/lib/theme/themes/vesper-dark.json
index 7d998b73..432fe8d1 100644
--- a/packages/ui/src/lib/theme/themes/vesper-dark.json
+++ b/packages/ui/src/lib/theme/themes/vesper-dark.json
@@ -56,6 +56,13 @@
       "infoBackground": "#FFC79920",
       "infoBorder": "#FFC79950"
     },
+    "pr": {
+      "open": "#99FFE4",
+      "draft": "#A0A0A0",
+      "blocked": "#FFC799",
+      "merged": "#ca99ff",
+      "closed": "#FF8080"
+    },
     "syntax": {
       "base": {
         "background": "#141414",
diff --git a/packages/ui/src/lib/theme/themes/vesper-light.json b/packages/ui/src/lib/theme/themes/vesper-light.json
index 13ceb158..8509017c 100644
--- a/packages/ui/src/lib/theme/themes/vesper-light.json
+++ b/packages/ui/src/lib/theme/themes/vesper-light.json
@@ -56,6 +56,13 @@
       "infoBackground": "#FFC79920",
       "infoBorder": "#FFC79950"
     },
+    "pr": {
+      "open": "#12b489",
+      "draft": "#A0A0A0",
+      "blocked": "#f4994e",
+      "merged": "#bf74e8",
+      "closed": "#FF8080"
+    },
     "syntax": {
       "base": {
         "background": "#F8F8F8",
diff --git a/packages/ui/src/lib/theme/themes/vitesse-dark-dark.json b/packages/ui/src/lib/theme/themes/vitesse-dark-dark.json
index 8a6c7e1b..2477608e 100644
--- a/packages/ui/src/lib/theme/themes/vitesse-dark-dark.json
+++ b/packages/ui/src/lib/theme/themes/vitesse-dark-dark.json
@@ -60,6 +60,13 @@
       "infoBackground": "#6394bf20",
       "infoBorder": "#6394bf50"
     },
+    "pr": {
+      "open": "#4d9375",
+      "draft": "#747f74",
+      "blocked": "#d4976c",
+      "merged": "#6c43be",
+      "closed": "#cb7676"
+    },
     "syntax": {
       "base": {
         "background": "#121212",
diff --git a/packages/ui/src/lib/theme/themes/vitesse-light-light.json b/packages/ui/src/lib/theme/themes/vitesse-light-light.json
index 1888ebe4..1efc27d5 100644
--- a/packages/ui/src/lib/theme/themes/vitesse-light-light.json
+++ b/packages/ui/src/lib/theme/themes/vitesse-light-light.json
@@ -60,6 +60,13 @@
       "infoBackground": "#296aa320",
       "infoBorder": "#296aa350"
     },
+    "pr": {
+      "open": "#1e754f",
+      "draft": "#a0ada0",
+      "blocked": "#a65e2b",
+      "merged": "#5843be",
+      "closed": "#ab5959"
+    },
     "syntax": {
       "base": {
         "background": "#ffffff",
diff --git a/packages/ui/src/lib/worktreeSessionCreator.ts b/packages/ui/src/lib/worktreeSessionCreator.ts
index 5a285bae..bf707d2b 100644
--- a/packages/ui/src/lib/worktreeSessionCreator.ts
+++ b/packages/ui/src/lib/worktreeSessionCreator.ts
@@ -229,6 +229,70 @@ export function isCreatingWorktree(): boolean {
   return isCreatingWorktreeSession;
 }
 
+export async function createWorktreeOnly(): Promise<string | null> {
+  if (isCreatingWorktreeSession) {
+    return null;
+  }
+
+  const activeProject = useProjectsStore.getState().getActiveProject();
+  if (!activeProject?.path) {
+    toast.error('No active project', {
+      description: 'Please select a project first.',
+    });
+    return null;
+  }
+
+  const projectDirectory = activeProject.path;
+  let isGitRepo = false;
+  try {
+    isGitRepo = await checkIsGitRepository(projectDirectory);
+  } catch {
+    // ignored
+  }
+
+  if (!isGitRepo) {
+    toast.error('Not a Git repository', {
+      description: 'Worktrees can only be created in Git repositories.',
+    });
+    return null;
+  }
+
+  isCreatingWorktreeSession = true;
+  startConfigUpdate('Creating new worktree...');
+
+  try {
+    const projectRef: ProjectRef = { id: activeProject.id, path: projectDirectory };
+    const preferredName = generateBranchName();
+    const setupCommands = await getWorktreeSetupCommands(projectRef);
+    const metadata = await createSdkWorktree(projectRef, {
+      preferredName,
+      setupCommands,
+    });
+
+    const rootBranch = await getRootBranch(projectRef.path).catch(() => undefined);
+    const status = await getWorktreeStatus(metadata.path).catch(() => undefined);
+
+    const branchLabel = metadata.branch || metadata.label || metadata.name;
+    toast.success('Worktree created', {
+      description: branchLabel
+        ? `${branchLabel}${rootBranch ? ` from ${rootBranch}` : ''}`
+        : status?.isDirty ? 'Created (dirty)' : 'Ready',
+    });
+
+    await useSessionStore.getState().loadSessions();
+    return metadata.path;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : 'Failed to create worktree';
+    toast.error('Failed to create worktree', {
+      description: message,
+    });
+    return null;
+  } finally {
+    finishConfigUpdate();
+    isCreatingWorktreeSession = false;
+  }
+}
+
 /**
  * Create a new session with a worktree for a specific branch.
  * Unlike createWorktreeSession(), this allows specifying the project and branch explicitly.
diff --git a/packages/ui/src/types/theme.ts b/packages/ui/src/types/theme.ts
index 5fe39063..ab351e22 100644
--- a/packages/ui/src/types/theme.ts
+++ b/packages/ui/src/types/theme.ts
@@ -67,6 +67,14 @@ export interface StatusColors {
   infoBorder: string;
 }
 
+export interface PullRequestColors {
+  open: string;
+  draft: string;
+  blocked: string;
+  merged: string;
+  closed: string;
+}
+
 export interface SyntaxBaseColors {
   background: string;
   foreground: string;
@@ -189,6 +197,7 @@ export interface Theme {
     surface: SurfaceColors;
     interactive: InteractiveColors;
     status: StatusColors;
+    pr?: PullRequestColors;
 
     syntax: SyntaxColors;