diff --git a/src/features/app/components/PinnedThreadList.test.tsx b/src/features/app/components/PinnedThreadList.test.tsx
index 704f91bfa..6ed7210ab 100644
--- a/src/features/app/components/PinnedThreadList.test.tsx
+++ b/src/features/app/components/PinnedThreadList.test.tsx
@@ -22,12 +22,13 @@ const statusMap = {
 };
 
 const baseProps = {
-  rows: [{ thread, depth: 0, workspaceId: "ws-1" }],
+  rows: [{ thread, depth: 0, workspaceId: "ws-1", hasChildren: false, isCollapsed: false }],
   activeWorkspaceId: "ws-1",
   activeThreadId: "thread-1",
   threadStatusById: statusMap,
   getThreadTime: () => "1h",
   isThreadPinned: () => true,
+  onToggleThreadCollapsed: vi.fn(),
   onSelectThread: vi.fn(),
   onShowThreadMenu: vi.fn(),
 };
@@ -76,8 +77,8 @@ describe("PinnedThreadList", () => {
       <PinnedThreadList
         {...baseProps}
         rows={[
-          { thread, depth: 0, workspaceId: "ws-1" },
-          { thread: otherThread, depth: 0, workspaceId: "ws-2" },
+          { thread, depth: 0, workspaceId: "ws-1", hasChildren: false, isCollapsed: false },
+          { thread: otherThread, depth: 0, workspaceId: "ws-2", hasChildren: false, isCollapsed: false },
         ]}
         onSelectThread={onSelectThread}
         onShowThreadMenu={onShowThreadMenu}
@@ -106,7 +107,7 @@ describe("PinnedThreadList", () => {
     const { container } = render(
       <PinnedThreadList
         {...baseProps}
-        rows={[{ thread: otherThread, depth: 0, workspaceId: "ws-2" }]}
+        rows={[{ thread: otherThread, depth: 0, workspaceId: "ws-2", hasChildren: false, isCollapsed: false }]}
         threadStatusById={{
           "thread-1": { isProcessing: false, hasUnread: false, isReviewing: true },
           "thread-2": { isProcessing: true, hasUnread: false, isReviewing: false },
@@ -121,4 +122,24 @@ describe("PinnedThreadList", () => {
     expect(row?.querySelector(".thread-status")?.className).toContain("unread");
     expect(row?.querySelector(".thread-status")?.className).not.toContain("processing");
   });
+
+  it("renders a collapse toggle for pinned threads with children", () => {
+    const onToggleThreadCollapsed = vi.fn();
+    const onSelectThread = vi.fn();
+
+    render(
+      <PinnedThreadList
+        {...baseProps}
+        rows={[{ thread, depth: 0, workspaceId: "ws-1", hasChildren: true, isCollapsed: true }]}
+        onToggleThreadCollapsed={onToggleThreadCollapsed}
+        onSelectThread={onSelectThread}
+      />,
+    );
+
+    const toggle = screen.getByRole("button", { name: "Expand subagent threads" });
+    fireEvent.click(toggle);
+
+    expect(onToggleThreadCollapsed).toHaveBeenCalledWith("ws-1", "thread-1");
+    expect(onSelectThread).not.toHaveBeenCalled();
+  });
 });
diff --git a/src/features/app/components/PinnedThreadList.tsx b/src/features/app/components/PinnedThreadList.tsx
index 5def5ee6d..b820f93ff 100644
--- a/src/features/app/components/PinnedThreadList.tsx
+++ b/src/features/app/components/PinnedThreadList.tsx
@@ -8,6 +8,8 @@ type PinnedThreadRow = {
   thread: ThreadSummary;
   depth: number;
   workspaceId: string;
+  hasChildren: boolean;
+  isCollapsed: boolean;
 };
 
 type PinnedThreadListProps = {
@@ -20,6 +22,7 @@ type PinnedThreadListProps = {
   getThreadTime: (thread: ThreadSummary) => string | null;
   getThreadArgsBadge?: (workspaceId: string, threadId: string) => string | null;
   isThreadPinned: (workspaceId: string, threadId: string) => boolean;
+  onToggleThreadCollapsed?: (workspaceId: string, threadId: string) => void;
   onSelectThread: (workspaceId: string, threadId: string) => void;
   onShowThreadMenu: (
     event: MouseEvent,
@@ -39,12 +42,13 @@ export function PinnedThreadList({
   getThreadTime,
   getThreadArgsBadge,
   isThreadPinned,
+  onToggleThreadCollapsed,
   onSelectThread,
   onShowThreadMenu,
 }: PinnedThreadListProps) {
   return (
     <div className="thread-list pinned-thread-list">
-      {rows.map(({ thread, depth, workspaceId }) => {
+      {rows.map(({ thread, depth, workspaceId, hasChildren, isCollapsed }) => {
         return (
           <ThreadRow
             key={`${workspaceId}:${thread.id}`}
@@ -52,6 +56,9 @@ export function PinnedThreadList({
             depth={depth}
             workspaceId={workspaceId}
             indentUnit={14}
+            hasChildren={hasChildren}
+            isCollapsed={isCollapsed}
+            onToggleThreadCollapsed={onToggleThreadCollapsed}
             activeWorkspaceId={activeWorkspaceId}
             activeThreadId={activeThreadId}
             threadStatusById={threadStatusById}
diff --git a/src/features/app/components/Sidebar.tsx b/src/features/app/components/Sidebar.tsx
index 53ce98a06..b88ca3769 100644
--- a/src/features/app/components/Sidebar.tsx
+++ b/src/features/app/components/Sidebar.tsx
@@ -8,7 +8,7 @@ import type {
   WorkspaceInfo,
 } from "../../../types";
 import { createPortal } from "react-dom";
-import { memo, useCallback, useEffect, useMemo, useState } from "react";
+import { memo, useCallback, useEffect, useMemo, useRef, useState } from "react";
 import type { MouseEvent, RefObject } from "react";
 import { FolderOpen } from "lucide-react";
 import Copy from "lucide-react/dist/esm/icons/copy";
@@ -52,6 +52,8 @@ type WorkspaceGroupSection = {
 type FlatThreadRow = {
   thread: ThreadSummary;
   depth: number;
+  hasChildren: boolean;
+  isCollapsed: boolean;
   workspaceId: string;
   workspaceName: string;
 };
@@ -243,6 +245,26 @@ export const Sidebar = memo(function Sidebar({
       ),
     [userInputRequests],
   );
+  const collapsedThreadTreesRef = useRef(new Set<string>());
+  const [collapsedThreadTreesVersion, setCollapsedThreadTreesVersion] = useState(0);
+  const isThreadCollapsed = useCallback(
+    (workspaceId: string, threadId: string) =>
+      collapsedThreadTreesRef.current.has(`${workspaceId}:${threadId}`),
+    [],
+  );
+  const toggleThreadCollapsed = useCallback(
+    (workspaceId: string, threadId: string) => {
+      const key = `${workspaceId}:${threadId}`;
+      const collapsed = collapsedThreadTreesRef.current;
+      if (collapsed.has(key)) {
+        collapsed.delete(key);
+      } else {
+        collapsed.add(key);
+      }
+      setCollapsedThreadTreesVersion((prev) => prev + 1);
+    },
+    [],
+  );
 
   const isWorkspaceMatch = useCallback(
     (workspace: WorkspaceInfo) => {
@@ -302,7 +324,12 @@ export const Sidebar = memo(function Sidebar({
   );
 
   const pinnedThreadRows = useMemo(() => {
-    type ThreadRow = { thread: ThreadSummary; depth: number };
+    type ThreadRow = {
+      thread: ThreadSummary;
+      depth: number;
+      hasChildren: boolean;
+      isCollapsed: boolean;
+    };
     const groups: Array<{
       pinTime: number;
       workspaceId: string;
@@ -323,6 +350,8 @@ export const Sidebar = memo(function Sidebar({
         workspace.id,
         getPinTimestamp,
         pinnedThreadsVersion,
+        collapsedThreadTreesVersion,
+        isThreadCollapsed,
       );
       if (!pinnedRows.length) {
         return;
@@ -369,6 +398,8 @@ export const Sidebar = memo(function Sidebar({
     getThreadRows,
     getPinTimestamp,
     pinnedThreadsVersion,
+    collapsedThreadTreesVersion,
+    isThreadCollapsed,
     isWorkspaceMatch,
   ]);
 
@@ -531,6 +562,8 @@ export const Sidebar = memo(function Sidebar({
           workspace.id,
           getPinTimestamp,
           pinnedThreadsVersion,
+          collapsedThreadTreesVersion,
+          isThreadCollapsed,
         );
         if (!unpinnedRows.length) {
           return;
@@ -596,6 +629,8 @@ export const Sidebar = memo(function Sidebar({
     getSortTimestamp,
     getThreadRows,
     pinnedThreadsVersion,
+    collapsedThreadTreesVersion,
+    isThreadCollapsed,
     threadListOrganizeMode,
     threadsByWorkspace,
   ]);
@@ -604,18 +639,22 @@ export const Sidebar = memo(function Sidebar({
     () => [
       sortedGroupedWorkspaces,
       flatThreadRows,
+      pinnedThreadRows,
       threadsByWorkspace,
       expandedWorkspaces,
       normalizedQuery,
       threadListOrganizeMode,
+      collapsedThreadTreesVersion,
     ],
     [
       sortedGroupedWorkspaces,
       flatThreadRows,
+      pinnedThreadRows,
       threadsByWorkspace,
       expandedWorkspaces,
       normalizedQuery,
       threadListOrganizeMode,
+      collapsedThreadTreesVersion,
     ],
   );
   const { sidebarBodyRef, scrollFade, updateScrollFade } =
@@ -871,6 +910,7 @@ export const Sidebar = memo(function Sidebar({
                 getThreadTime={getThreadTime}
                 getThreadArgsBadge={getThreadArgsBadge}
                 isThreadPinned={isThreadPinned}
+                onToggleThreadCollapsed={toggleThreadCollapsed}
                 onSelectThread={onSelectThread}
                 onShowThreadMenu={showThreadMenu}
                 getWorkspaceLabel={isThreadsOnlyMode ? getWorkspaceLabel : undefined}
@@ -904,6 +944,7 @@ export const Sidebar = memo(function Sidebar({
                       getThreadTime={getThreadTime}
                       getThreadArgsBadge={getThreadArgsBadge}
                       isThreadPinned={isThreadPinned}
+                      onToggleThreadCollapsed={toggleThreadCollapsed}
                       onSelectThread={onSelectThread}
                       onShowThreadMenu={showThreadMenu}
                       getWorkspaceLabel={getWorkspaceLabel}
@@ -970,6 +1011,8 @@ export const Sidebar = memo(function Sidebar({
                         entry.id,
                         getPinTimestamp,
                         pinnedThreadsVersion,
+                        collapsedThreadTreesVersion,
+                        isThreadCollapsed,
                       );
                       const nextCursor =
                         threadListCursorByWorkspace[entry.id] ?? null;
@@ -1097,6 +1140,8 @@ export const Sidebar = memo(function Sidebar({
                               isThreadPinned={isThreadPinned}
                               getPinTimestamp={getPinTimestamp}
                               pinnedThreadsVersion={pinnedThreadsVersion}
+                              collapsedThreadTreesVersion={collapsedThreadTreesVersion}
+                              isThreadCollapsed={isThreadCollapsed}
                               onSelectWorkspace={onSelectWorkspace}
                               onConnectWorkspace={onConnectWorkspace}
                               onToggleWorkspaceCollapse={onToggleWorkspaceCollapse}
@@ -1105,6 +1150,7 @@ export const Sidebar = memo(function Sidebar({
                               onShowWorktreeMenu={showCloneMenu}
                               onToggleExpanded={handleToggleExpanded}
                               onLoadOlderThreads={onLoadOlderThreads}
+                              onToggleThreadCollapsed={toggleThreadCollapsed}
                               sectionLabel="Clone agents"
                               sectionIcon={
                                 <Copy className="worktree-header-icon" aria-hidden />
@@ -1131,6 +1177,8 @@ export const Sidebar = memo(function Sidebar({
                               isThreadPinned={isThreadPinned}
                               getPinTimestamp={getPinTimestamp}
                               pinnedThreadsVersion={pinnedThreadsVersion}
+                              collapsedThreadTreesVersion={collapsedThreadTreesVersion}
+                              isThreadCollapsed={isThreadCollapsed}
                               onSelectWorkspace={onSelectWorkspace}
                               onConnectWorkspace={onConnectWorkspace}
                               onToggleWorkspaceCollapse={onToggleWorkspaceCollapse}
@@ -1139,6 +1187,7 @@ export const Sidebar = memo(function Sidebar({
                               onShowWorktreeMenu={showWorktreeMenu}
                               onToggleExpanded={handleToggleExpanded}
                               onLoadOlderThreads={onLoadOlderThreads}
+                              onToggleThreadCollapsed={toggleThreadCollapsed}
                             />
                           )}
                           {showThreadList && (
@@ -1159,6 +1208,7 @@ export const Sidebar = memo(function Sidebar({
                               isThreadPinned={isThreadPinned}
                               onToggleExpanded={handleToggleExpanded}
                               onLoadOlderThreads={onLoadOlderThreads}
+                              onToggleThreadCollapsed={toggleThreadCollapsed}
                               onSelectThread={onSelectThread}
                               onShowThreadMenu={showThreadMenu}
                             />
diff --git a/src/features/app/components/ThreadList.test.tsx b/src/features/app/components/ThreadList.test.tsx
index 0451cab03..1b8d56f41 100644
--- a/src/features/app/components/ThreadList.test.tsx
+++ b/src/features/app/components/ThreadList.test.tsx
@@ -24,7 +24,7 @@ const statusMap = {
 const baseProps = {
   workspaceId: "ws-1",
   pinnedRows: [],
-  unpinnedRows: [{ thread, depth: 0 }],
+  unpinnedRows: [{ thread, depth: 0, hasChildren: false, isCollapsed: false }],
   totalThreadRoots: 1,
   isExpanded: false,
   nextCursor: null,
@@ -37,6 +37,7 @@ const baseProps = {
   isThreadPinned: () => false,
   onToggleExpanded: vi.fn(),
   onLoadOlderThreads: vi.fn(),
+  onToggleThreadCollapsed: vi.fn(),
   onSelectThread: vi.fn(),
   onShowThreadMenu: vi.fn(),
 };
@@ -111,8 +112,8 @@ describe("ThreadList", () => {
         {...baseProps}
         nested
         unpinnedRows={[
-          { thread, depth: 0 },
-          { thread: nestedThread, depth: 1 },
+          { thread, depth: 0, hasChildren: false, isCollapsed: false },
+          { thread: nestedThread, depth: 1, hasChildren: false, isCollapsed: false },
         ]}
         onShowThreadMenu={onShowThreadMenu}
       />,
@@ -134,10 +135,30 @@ describe("ThreadList", () => {
     );
   });
 
+  it("renders a collapse toggle for threads with children", () => {
+    const onToggleThreadCollapsed = vi.fn();
+    const onSelectThread = vi.fn();
+    render(
+      <ThreadList
+        {...baseProps}
+        unpinnedRows={[{ thread, depth: 0, hasChildren: true, isCollapsed: true }]}
+        onToggleThreadCollapsed={onToggleThreadCollapsed}
+        onSelectThread={onSelectThread}
+      />,
+    );
+
+    const toggle = screen.getByRole("button", { name: "Expand subagent threads" });
+    fireEvent.click(toggle);
+
+    expect(onToggleThreadCollapsed).toHaveBeenCalledWith("ws-1", "thread-1");
+    expect(onSelectThread).not.toHaveBeenCalled();
+  });
+
   it("shows blue unread-style status when a thread is waiting for user input", () => {
     const { container } = render(
       <ThreadList
         {...baseProps}
+        onToggleThreadCollapsed={vi.fn()}
         threadStatusById={{
           "thread-1": { isProcessing: true, hasUnread: false, isReviewing: false },
           "thread-2": { isProcessing: false, hasUnread: false, isReviewing: false },
diff --git a/src/features/app/components/ThreadList.tsx b/src/features/app/components/ThreadList.tsx
index 732b9c65d..f09698b7b 100644
--- a/src/features/app/components/ThreadList.tsx
+++ b/src/features/app/components/ThreadList.tsx
@@ -7,6 +7,8 @@ import { ThreadRow } from "./ThreadRow";
 type ThreadListRow = {
   thread: ThreadSummary;
   depth: number;
+  hasChildren: boolean;
+  isCollapsed: boolean;
 };
 
 type ThreadListProps = {
@@ -28,6 +30,7 @@ type ThreadListProps = {
   isThreadPinned: (workspaceId: string, threadId: string) => boolean;
   onToggleExpanded: (workspaceId: string) => void;
   onLoadOlderThreads: (workspaceId: string) => void;
+  onToggleThreadCollapsed?: (workspaceId: string, threadId: string) => void;
   onSelectThread: (workspaceId: string, threadId: string) => void;
   onShowThreadMenu: (
     event: MouseEvent,
@@ -56,6 +59,7 @@ export function ThreadList({
   isThreadPinned,
   onToggleExpanded,
   onLoadOlderThreads,
+  onToggleThreadCollapsed,
   onSelectThread,
   onShowThreadMenu,
 }: ThreadListProps) {
@@ -63,13 +67,16 @@ export function ThreadList({
 
   return (
     <div className={`thread-list${nested ? " thread-list-nested" : ""}`}>
-      {pinnedRows.map(({ thread, depth }) => (
+      {pinnedRows.map(({ thread, depth, hasChildren, isCollapsed }) => (
         <ThreadRow
           key={thread.id}
           thread={thread}
           depth={depth}
           workspaceId={workspaceId}
           indentUnit={indentUnit}
+          hasChildren={hasChildren}
+          isCollapsed={isCollapsed}
+          onToggleThreadCollapsed={onToggleThreadCollapsed}
           activeWorkspaceId={activeWorkspaceId}
           activeThreadId={activeThreadId}
           threadStatusById={threadStatusById}
@@ -84,13 +91,16 @@ export function ThreadList({
       {pinnedRows.length > 0 && unpinnedRows.length > 0 && (
         <div className="thread-list-separator" aria-hidden="true" />
       )}
-      {unpinnedRows.map(({ thread, depth }) => (
+      {unpinnedRows.map(({ thread, depth, hasChildren, isCollapsed }) => (
         <ThreadRow
           key={thread.id}
           thread={thread}
           depth={depth}
           workspaceId={workspaceId}
           indentUnit={indentUnit}
+          hasChildren={hasChildren}
+          isCollapsed={isCollapsed}
+          onToggleThreadCollapsed={onToggleThreadCollapsed}
           activeWorkspaceId={activeWorkspaceId}
           activeThreadId={activeThreadId}
           threadStatusById={threadStatusById}
diff --git a/src/features/app/components/ThreadRow.tsx b/src/features/app/components/ThreadRow.tsx
index 05650582f..50205799b 100644
--- a/src/features/app/components/ThreadRow.tsx
+++ b/src/features/app/components/ThreadRow.tsx
@@ -1,4 +1,6 @@
 import type { CSSProperties, MouseEvent } from "react";
+import ChevronDown from "lucide-react/dist/esm/icons/chevron-down";
+import ChevronRight from "lucide-react/dist/esm/icons/chevron-right";
 
 import type { ThreadSummary } from "../../../types";
 import { getThreadStatusClass, type ThreadStatusById } from "../../../utils/threadStatus";
@@ -8,6 +10,9 @@ type ThreadRowProps = {
   depth: number;
   workspaceId: string;
   indentUnit: number;
+  hasChildren?: boolean;
+  isCollapsed?: boolean;
+  onToggleThreadCollapsed?: (workspaceId: string, threadId: string) => void;
   activeWorkspaceId: string | null;
   activeThreadId: string | null;
   threadStatusById: ThreadStatusById;
@@ -30,6 +35,9 @@ export function ThreadRow({
   depth,
   workspaceId,
   indentUnit,
+  hasChildren = false,
+  isCollapsed = false,
+  onToggleThreadCollapsed,
   activeWorkspaceId,
   activeThreadId,
   threadStatusById,
@@ -62,6 +70,10 @@ export function ThreadRow({
   );
   const canPin = depth === 0;
   const isPinned = canPin && isThreadPinned(workspaceId, thread.id);
+  const TreeIcon = isCollapsed ? ChevronRight : ChevronDown;
+  const treeLabel = isCollapsed
+    ? "Expand subagent threads"
+    : "Collapse subagent threads";
 
   return (
     <div
@@ -83,6 +95,25 @@ export function ThreadRow({
       }}
     >
       <span className={`thread-status ${statusClass}`} aria-hidden />
+      {onToggleThreadCollapsed ? (
+        hasChildren ? (
+          <button
+            type="button"
+            className="thread-tree-toggle"
+            aria-label={treeLabel}
+            aria-expanded={!isCollapsed}
+            onClick={(event) => {
+              event.preventDefault();
+              event.stopPropagation();
+              onToggleThreadCollapsed(workspaceId, thread.id);
+            }}
+          >
+            <TreeIcon size={12} aria-hidden />
+          </button>
+        ) : (
+          <span className="thread-tree-spacer" aria-hidden />
+        )
+      ) : null}
       {isPinned && <span className="thread-pin-icon" aria-label="Pinned">📌</span>}
       <span className="thread-name">{thread.name}</span>
       <div className="thread-meta">
diff --git a/src/features/app/components/WorktreeSection.test.tsx b/src/features/app/components/WorktreeSection.test.tsx
index de168687a..c5fe30b42 100644
--- a/src/features/app/components/WorktreeSection.test.tsx
+++ b/src/features/app/components/WorktreeSection.test.tsx
@@ -38,6 +38,8 @@ describe("WorktreeSection", () => {
         isThreadPinned={() => false}
         getPinTimestamp={() => null}
         pinnedThreadsVersion={0}
+        collapsedThreadTreesVersion={0}
+        isThreadCollapsed={() => false}
         onSelectWorkspace={vi.fn()}
         onConnectWorkspace={vi.fn()}
         onToggleWorkspaceCollapse={vi.fn()}
@@ -46,6 +48,7 @@ describe("WorktreeSection", () => {
         onShowWorktreeMenu={vi.fn()}
         onToggleExpanded={vi.fn()}
         onLoadOlderThreads={vi.fn()}
+        onToggleThreadCollapsed={vi.fn()}
       />,
     );
 
diff --git a/src/features/app/components/WorktreeSection.tsx b/src/features/app/components/WorktreeSection.tsx
index e96024966..f076c2c88 100644
--- a/src/features/app/components/WorktreeSection.tsx
+++ b/src/features/app/components/WorktreeSection.tsx
@@ -8,8 +8,18 @@ import { ThreadLoading } from "./ThreadLoading";
 import { WorktreeCard } from "./WorktreeCard";
 
 type ThreadRowsResult = {
-  pinnedRows: Array<{ thread: ThreadSummary; depth: number }>;
-  unpinnedRows: Array<{ thread: ThreadSummary; depth: number }>;
+  pinnedRows: Array<{
+    thread: ThreadSummary;
+    depth: number;
+    hasChildren: boolean;
+    isCollapsed: boolean;
+  }>;
+  unpinnedRows: Array<{
+    thread: ThreadSummary;
+    depth: number;
+    hasChildren: boolean;
+    isCollapsed: boolean;
+  }>;
   totalRoots: number;
   hasMoreRoots: boolean;
 };
@@ -32,12 +42,16 @@ type WorktreeSectionProps = {
     workspaceId: string,
     getPinTimestamp: (workspaceId: string, threadId: string) => number | null,
     pinVersion?: number,
+    collapseVersion?: number,
+    isThreadCollapsed?: (workspaceId: string, threadId: string) => boolean,
   ) => ThreadRowsResult;
   getThreadTime: (thread: ThreadSummary) => string | null;
   getThreadArgsBadge?: (workspaceId: string, threadId: string) => string | null;
   isThreadPinned: (workspaceId: string, threadId: string) => boolean;
   getPinTimestamp: (workspaceId: string, threadId: string) => number | null;
   pinnedThreadsVersion: number;
+  collapsedThreadTreesVersion: number;
+  isThreadCollapsed: (workspaceId: string, threadId: string) => boolean;
   onSelectWorkspace: (id: string) => void;
   onConnectWorkspace: (workspace: WorkspaceInfo) => void;
   onToggleWorkspaceCollapse: (workspaceId: string, collapsed: boolean) => void;
@@ -51,6 +65,7 @@ type WorktreeSectionProps = {
   onShowWorktreeMenu: (event: MouseEvent, worktree: WorkspaceInfo) => void;
   onToggleExpanded: (workspaceId: string) => void;
   onLoadOlderThreads: (workspaceId: string) => void;
+  onToggleThreadCollapsed: (workspaceId: string, threadId: string) => void;
   sectionLabel?: string;
   sectionIcon?: ReactNode;
   className?: string;
@@ -74,6 +89,8 @@ export function WorktreeSection({
   isThreadPinned,
   getPinTimestamp,
   pinnedThreadsVersion,
+  collapsedThreadTreesVersion,
+  isThreadCollapsed,
   onSelectWorkspace,
   onConnectWorkspace,
   onToggleWorkspaceCollapse,
@@ -82,6 +99,7 @@ export function WorktreeSection({
   onShowWorktreeMenu,
   onToggleExpanded,
   onLoadOlderThreads,
+  onToggleThreadCollapsed,
   sectionLabel = "Worktrees",
   sectionIcon,
   className,
@@ -119,6 +137,8 @@ export function WorktreeSection({
             worktree.id,
             getPinTimestamp,
             pinnedThreadsVersion,
+            collapsedThreadTreesVersion,
+            isThreadCollapsed,
           );
 
           return (
@@ -152,6 +172,7 @@ export function WorktreeSection({
                   isThreadPinned={isThreadPinned}
                   onToggleExpanded={onToggleExpanded}
                   onLoadOlderThreads={onLoadOlderThreads}
+                  onToggleThreadCollapsed={onToggleThreadCollapsed}
                   onSelectThread={onSelectThread}
                   onShowThreadMenu={onShowThreadMenu}
                 />
diff --git a/src/features/app/hooks/useThreadRows.test.tsx b/src/features/app/hooks/useThreadRows.test.tsx
index 2b1231183..7ea7a91f0 100644
--- a/src/features/app/hooks/useThreadRows.test.tsx
+++ b/src/features/app/hooks/useThreadRows.test.tsx
@@ -125,4 +125,69 @@ describe("useThreadRows", () => {
       ["thread-child", 1],
     ]);
   });
+
+  it("skips descendants when a thread is collapsed", () => {
+    const threads: ThreadSummary[] = [
+      { id: "thread-root", name: "Root", updatedAt: 3 },
+      { id: "thread-child-a", name: "Child A", updatedAt: 2 },
+      { id: "thread-child-b", name: "Child B", updatedAt: 1 },
+    ];
+    const getPinTimestamp = vi.fn(() => null);
+    const { result } = renderHook(() =>
+      useThreadRows({
+        "thread-child-a": "thread-root",
+        "thread-child-b": "thread-child-a",
+      }),
+    );
+
+    const expanded = result.current.getThreadRows(
+      threads,
+      true,
+      "ws-1",
+      getPinTimestamp,
+      0,
+      0,
+      () => false,
+    );
+    expect(expanded.unpinnedRows.map((row) => [row.thread.id, row.depth])).toEqual([
+      ["thread-root", 0],
+      ["thread-child-a", 1],
+      ["thread-child-b", 2],
+    ]);
+
+    const collapsedRoot = result.current.getThreadRows(
+      threads,
+      true,
+      "ws-1",
+      getPinTimestamp,
+      0,
+      1,
+      (_workspaceId, threadId) => threadId === "thread-root",
+    );
+    expect(collapsedRoot.unpinnedRows.map((row) => [row.thread.id, row.depth])).toEqual([
+      ["thread-root", 0],
+    ]);
+    expect(collapsedRoot.unpinnedRows[0]).toMatchObject({
+      hasChildren: true,
+      isCollapsed: true,
+    });
+
+    const collapsedChild = result.current.getThreadRows(
+      threads,
+      true,
+      "ws-1",
+      getPinTimestamp,
+      0,
+      2,
+      (_workspaceId, threadId) => threadId === "thread-child-a",
+    );
+    expect(collapsedChild.unpinnedRows.map((row) => [row.thread.id, row.depth])).toEqual([
+      ["thread-root", 0],
+      ["thread-child-a", 1],
+    ]);
+    expect(collapsedChild.unpinnedRows[1]).toMatchObject({
+      hasChildren: true,
+      isCollapsed: true,
+    });
+  });
 });
diff --git a/src/features/app/hooks/useThreadRows.ts b/src/features/app/hooks/useThreadRows.ts
index e60b0a43c..704169a02 100644
--- a/src/features/app/hooks/useThreadRows.ts
+++ b/src/features/app/hooks/useThreadRows.ts
@@ -5,6 +5,8 @@ import type { ThreadSummary } from "../../../types";
 type ThreadRow = {
   thread: ThreadSummary;
   depth: number;
+  hasChildren: boolean;
+  isCollapsed: boolean;
 };
 
 type ThreadRowResult = {
@@ -16,9 +18,12 @@ type ThreadRowResult = {
 
 type ThreadRowCacheEntry = {
   pinVersion: number;
+  collapseVersion: number;
   result: ThreadRowResult;
 };
 
+const isNeverCollapsed = () => false;
+
 export function useThreadRows(threadParentById: Record<string, string>) {
   const cacheRef = useRef(
     new WeakMap<
@@ -42,11 +47,17 @@ export function useThreadRows(threadParentById: Record<string, string>) {
       workspaceId: string,
       getPinTimestamp: (workspaceId: string, threadId: string) => number | null,
       pinVersion = 0,
+      collapseVersion = 0,
+      isThreadCollapsed: (workspaceId: string, threadId: string) => boolean = isNeverCollapsed,
     ): ThreadRowResult => {
       const cacheKey = `${workspaceId}:${isExpanded ? "1" : "0"}`;
       const threadCache = cacheRef.current.get(threads);
       const cachedEntry = threadCache?.get(cacheKey);
-      if (cachedEntry && cachedEntry.pinVersion === pinVersion) {
+      if (
+        cachedEntry &&
+        cachedEntry.pinVersion === pinVersion &&
+        cachedEntry.collapseVersion === collapseVersion
+      ) {
         return cachedEntry.result;
       }
 
@@ -104,17 +115,33 @@ export function useThreadRows(threadParentById: Record<string, string>) {
         thread: ThreadSummary,
         depth: number,
         rows: ThreadRow[],
+        visited: Set<string>,
       ) => {
-        rows.push({ thread, depth });
+        if (visited.has(thread.id)) {
+          return;
+        }
+        visited.add(thread.id);
         const children = childrenByParent.get(thread.id) ?? [];
-        children.forEach((child) => appendThread(child, depth + 1, rows));
+        const hasChildren = children.length > 0;
+        const collapsed = hasChildren
+          ? isThreadCollapsed(workspaceId, thread.id)
+          : false;
+        rows.push({ thread, depth, hasChildren, isCollapsed: collapsed });
+        if (collapsed) {
+          return;
+        }
+        children.forEach((child) => appendThread(child, depth + 1, rows, visited));
       };
 
       const pinnedRows: ThreadRow[] = [];
-      pinnedRoots.forEach((thread) => appendThread(thread, 0, pinnedRows));
+      pinnedRoots.forEach((thread) =>
+        appendThread(thread, 0, pinnedRows, new Set<string>()),
+      );
 
       const unpinnedRows: ThreadRow[] = [];
-      visibleRoots.forEach((thread) => appendThread(thread, 0, unpinnedRows));
+      visibleRoots.forEach((thread) =>
+        appendThread(thread, 0, unpinnedRows, new Set<string>()),
+      );
 
       const result = {
         pinnedRows,
@@ -125,6 +152,7 @@ export function useThreadRows(threadParentById: Record<string, string>) {
       const nextThreadCache = threadCache ?? new Map<string, ThreadRowCacheEntry>();
       nextThreadCache.set(cacheKey, {
         pinVersion,
+        collapseVersion,
         result,
       });
       if (!threadCache) {
diff --git a/src/styles/sidebar.css b/src/styles/sidebar.css
index 0d319f0cf..215c35c70 100644
--- a/src/styles/sidebar.css
+++ b/src/styles/sidebar.css
@@ -967,6 +967,45 @@
   margin-left: 4px;
 }
 
+.thread-tree-spacer,
+.thread-tree-toggle {
+  width: 14px;
+  height: 14px;
+  flex: 0 0 14px;
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+}
+
+.thread-tree-toggle {
+  border: none;
+  background: transparent;
+  color: var(--text-faint);
+  padding: 0;
+  cursor: pointer;
+  -webkit-app-region: no-drag;
+  opacity: 0;
+  pointer-events: none;
+  transition: opacity 0.15s ease, color 0.15s ease;
+}
+
+.thread-tree-toggle:hover {
+  color: var(--text-strong);
+}
+
+.thread-row:hover .thread-tree-toggle,
+.thread-row:focus-within .thread-tree-toggle {
+  opacity: 1;
+  pointer-events: auto;
+}
+
+@media (hover: none) {
+  .thread-tree-toggle {
+    opacity: 1;
+    pointer-events: auto;
+  }
+}
+
 .thread-pin-icon {
   font-size: 10px;
   margin-right: 2px;