diff --git a/src/App.tsx b/src/App.tsx
index b4390a41e..e115b8737 100644
--- a/src/App.tsx
+++ b/src/App.tsx
@@ -469,6 +469,7 @@ function MainApp() {
     activeItems,
     approvals,
     threadsByWorkspace,
+    threadParentById,
     threadStatusById,
     threadListLoadingByWorkspace,
     threadListPagingByWorkspace,
@@ -889,6 +890,7 @@ function MainApp() {
     groupedWorkspaces,
     hasWorkspaceGroups: workspaceGroups.length > 0,
     threadsByWorkspace,
+    threadParentById,
     threadStatusById,
     threadListLoadingByWorkspace,
     threadListPagingByWorkspace,
diff --git a/src/features/app/components/Sidebar.tsx b/src/features/app/components/Sidebar.tsx
index 47d65c745..519e7193f 100644
--- a/src/features/app/components/Sidebar.tsx
+++ b/src/features/app/components/Sidebar.tsx
@@ -1,7 +1,7 @@
 import type { RateLimitSnapshot, ThreadSummary, WorkspaceInfo } from "../../../types";
 import { FolderKanban, Layers, ScrollText, Settings } from "lucide-react";
 import { createPortal } from "react-dom";
-import { useCallback, useEffect, useRef, useState } from "react";
+import { useCallback, useEffect, useRef, useState, type CSSProperties } from "react";
 import { Menu, MenuItem } from "@tauri-apps/api/menu";
 import { LogicalPosition } from "@tauri-apps/api/dpi";
 import { getCurrentWindow } from "@tauri-apps/api/window";
@@ -20,6 +20,7 @@ type SidebarProps = {
   groupedWorkspaces: WorkspaceGroupSection[];
   hasWorkspaceGroups: boolean;
   threadsByWorkspace: Record<string, ThreadSummary[]>;
+  threadParentById: Record<string, string>;
   threadStatusById: Record<
     string,
     { isProcessing: boolean; hasUnread: boolean; isReviewing: boolean }
@@ -54,6 +55,7 @@ export function Sidebar({
   groupedWorkspaces,
   hasWorkspaceGroups,
   threadsByWorkspace,
+  threadParentById,
   threadStatusById,
   threadListLoadingByWorkspace,
   threadListPagingByWorkspace,
@@ -110,6 +112,43 @@ export function Sidebar({
   const sidebarBodyRef = useRef<HTMLDivElement | null>(null);
   const [scrollFade, setScrollFade] = useState({ top: false, bottom: false });
 
+  const getThreadRows = useCallback(
+    (threads: ThreadSummary[], isExpanded: boolean) => {
+      const threadIds = new Set(threads.map((thread) => thread.id));
+      const childrenByParent = new Map<string, ThreadSummary[]>();
+      const roots: ThreadSummary[] = [];
+
+      threads.forEach((thread) => {
+        const parentId = threadParentById[thread.id];
+        if (parentId && parentId !== thread.id && threadIds.has(parentId)) {
+          const list = childrenByParent.get(parentId) ?? [];
+          list.push(thread);
+          childrenByParent.set(parentId, list);
+        } else {
+          roots.push(thread);
+        }
+      });
+
+      const visibleRootCount = isExpanded ? roots.length : 3;
+      const visibleRoots = roots.slice(0, visibleRootCount);
+      const rows: Array<{ thread: ThreadSummary; depth: number }> = [];
+      const appendThread = (thread: ThreadSummary, depth: number) => {
+        rows.push({ thread, depth });
+        const children = childrenByParent.get(thread.id) ?? [];
+        children.forEach((child) => appendThread(child, depth + 1));
+      };
+
+      visibleRoots.forEach((thread) => appendThread(thread, 0));
+
+      return {
+        rows,
+        totalRoots: roots.length,
+        hasMoreRoots: roots.length > visibleRootCount,
+      };
+    },
+    [threadParentById],
+  );
+
   const updateScrollFade = useCallback(() => {
     const node = sidebarBodyRef.current;
     if (!node) {
@@ -388,6 +427,11 @@ export function Sidebar({
                   {group.workspaces.map((entry) => {
                   const threads = threadsByWorkspace[entry.id] ?? [];
                   const isCollapsed = entry.settings.sidebarCollapsed;
+                  const isExpanded = expandedWorkspaces.has(entry.id);
+                  const {
+                    rows: threadRows,
+                    totalRoots: totalThreadRoots,
+                  } = getThreadRows(threads, isExpanded);
                   const showThreads = !isCollapsed && threads.length > 0;
                   const isLoadingThreads =
                     threadListLoadingByWorkspace[entry.id] ?? false;
@@ -596,121 +640,157 @@ export function Sidebar({
                                   </div>
                                   {showWorktreeThreads && (
                                     <div className="thread-list thread-list-nested">
-                                      {(expandedWorkspaces.has(worktree.id)
-                                        ? worktreeThreads
-                                        : worktreeThreads.slice(0, 3)
-                                      ).map((thread) => {
-                                        const relativeTime = getThreadTime(thread);
+                                      {(() => {
+                                        const isWorktreeExpanded =
+                                          expandedWorkspaces.has(worktree.id);
+                                        const {
+                                          rows: worktreeThreadRows,
+                                          totalRoots: totalWorktreeRoots,
+                                        } = getThreadRows(
+                                          worktreeThreads,
+                                          isWorktreeExpanded,
+                                        );
                                         return (
-                                          <div
-                                            key={thread.id}
-                                            className={`thread-row ${
-                                              worktree.id === activeWorkspaceId &&
-                                              thread.id === activeThreadId
-                                                ? "active"
-                                                : ""
-                                            }`}
-                                            onClick={() =>
-                                              onSelectThread(worktree.id, thread.id)
-                                            }
-                                            onContextMenu={(event) =>
-                                              showThreadMenu(
-                                                event,
-                                                worktree.id,
-                                                thread.id,
-                                              )
-                                            }
-                                            role="button"
-                                            tabIndex={0}
-                                            onKeyDown={(event) => {
-                                              if (
-                                                event.key === "Enter" ||
-                                                event.key === " "
-                                              ) {
-                                                event.preventDefault();
-                                                onSelectThread(worktree.id, thread.id);
-                                              }
-                                            }}
-                                          >
-                                            <span
-                                              className={`thread-status ${
-                                                threadStatusById[thread.id]?.isReviewing
-                                                  ? "reviewing"
-                                                  : threadStatusById[thread.id]?.isProcessing
-                                                    ? "processing"
-                                                    : threadStatusById[thread.id]?.hasUnread
-                                                      ? "unread"
-                                                      : "ready"
-                                              }`}
-                                              aria-hidden
-                                            />
-                                            <span className="thread-name">
-                                              {thread.name}
-                                            </span>
-                                            <div className="thread-meta">
-                                              {relativeTime && (
-                                                <span className="thread-time">
-                                                  {relativeTime}
-                                                </span>
-                                              )}
-                                              <div className="thread-menu">
+                                          <>
+                                            {worktreeThreadRows.map(
+                                              ({ thread, depth }) => {
+                                                const relativeTime =
+                                                  getThreadTime(thread);
+                                                const indentStyle =
+                                                  depth > 0
+                                                    ? ({
+                                                        "--thread-indent": `${depth * 14}px`,
+                                                      } as CSSProperties)
+                                                    : undefined;
+                                                return (
+                                                  <div
+                                                    key={thread.id}
+                                                    className={`thread-row ${
+                                                      worktree.id ===
+                                                        activeWorkspaceId &&
+                                                      thread.id === activeThreadId
+                                                        ? "active"
+                                                        : ""
+                                                    }`}
+                                                    style={indentStyle}
+                                                    onClick={() =>
+                                                      onSelectThread(
+                                                        worktree.id,
+                                                        thread.id,
+                                                      )
+                                                    }
+                                                    onContextMenu={(event) =>
+                                                      showThreadMenu(
+                                                        event,
+                                                        worktree.id,
+                                                        thread.id,
+                                                      )
+                                                    }
+                                                    role="button"
+                                                    tabIndex={0}
+                                                    onKeyDown={(event) => {
+                                                      if (
+                                                        event.key === "Enter" ||
+                                                        event.key === " "
+                                                      ) {
+                                                        event.preventDefault();
+                                                        onSelectThread(
+                                                          worktree.id,
+                                                          thread.id,
+                                                        );
+                                                      }
+                                                    }}
+                                                  >
+                                                    <span
+                                                      className={`thread-status ${
+                                                        threadStatusById[thread.id]
+                                                          ?.isReviewing
+                                                          ? "reviewing"
+                                                          : threadStatusById[
+                                                                thread.id
+                                                              ]?.isProcessing
+                                                            ? "processing"
+                                                            : threadStatusById[
+                                                                  thread.id
+                                                                ]?.hasUnread
+                                                              ? "unread"
+                                                              : "ready"
+                                                      }`}
+                                                      aria-hidden
+                                                    />
+                                                    <span className="thread-name">
+                                                      {thread.name}
+                                                    </span>
+                                                    <div className="thread-meta">
+                                                      {relativeTime && (
+                                                        <span className="thread-time">
+                                                          {relativeTime}
+                                                        </span>
+                                                      )}
+                                                      <div className="thread-menu">
+                                                        <button
+                                                          className="thread-menu-trigger"
+                                                          aria-label="Thread menu"
+                                                          onMouseDown={(event) =>
+                                                            event.stopPropagation()
+                                                          }
+                                                          onClick={(event) =>
+                                                            showThreadMenu(
+                                                              event,
+                                                              worktree.id,
+                                                              thread.id,
+                                                            )
+                                                          }
+                                                        >
+                                                          ...
+                                                        </button>
+                                                      </div>
+                                                    </div>
+                                                  </div>
+                                                );
+                                              },
+                                            )}
+                                            {totalWorktreeRoots > 3 && (
+                                              <button
+                                                className="thread-more"
+                                                onClick={(event) => {
+                                                  event.stopPropagation();
+                                                  setExpandedWorkspaces(
+                                                    (prev) => {
+                                                      const next = new Set(prev);
+                                                      if (next.has(worktree.id)) {
+                                                        next.delete(worktree.id);
+                                                      } else {
+                                                        next.add(worktree.id);
+                                                      }
+                                                      return next;
+                                                    },
+                                                  );
+                                                }}
+                                              >
+                                                {isWorktreeExpanded
+                                                  ? "Show less"
+                                                  : "More..."}
+                                              </button>
+                                            )}
+                                            {isWorktreeExpanded &&
+                                              worktreeNextCursor && (
                                                 <button
-                                                  className="thread-menu-trigger"
-                                                  aria-label="Thread menu"
-                                                  onMouseDown={(event) =>
-                                                    event.stopPropagation()
-                                                  }
-                                                  onClick={(event) =>
-                                                    showThreadMenu(
-                                                      event,
-                                                      worktree.id,
-                                                      thread.id,
-                                                    )
-                                                  }
+                                                  className="thread-more"
+                                                  onClick={(event) => {
+                                                    event.stopPropagation();
+                                                    onLoadOlderThreads(worktree.id);
+                                                  }}
+                                                  disabled={isWorktreePaging}
                                                 >
-                                                  ...
+                                                  {isWorktreePaging
+                                                    ? "Loading..."
+                                                    : "Load older..."}
                                                 </button>
-                                              </div>
-                                            </div>
-                                          </div>
+                                              )}
+                                          </>
                                         );
-                                      })}
-                                      {worktreeThreads.length > 3 && (
-                                        <button
-                                          className="thread-more"
-                                          onClick={(event) => {
-                                            event.stopPropagation();
-                                            setExpandedWorkspaces((prev) => {
-                                              const next = new Set(prev);
-                                              if (next.has(worktree.id)) {
-                                                next.delete(worktree.id);
-                                              } else {
-                                                next.add(worktree.id);
-                                              }
-                                              return next;
-                                            });
-                                          }}
-                                        >
-                                          {expandedWorkspaces.has(worktree.id)
-                                            ? "Show less"
-                                            : "More..."}
-                                        </button>
-                                      )}
-                                      {expandedWorkspaces.has(worktree.id) &&
-                                        worktreeNextCursor && (
-                                          <button
-                                            className="thread-more"
-                                            onClick={(event) => {
-                                              event.stopPropagation();
-                                              onLoadOlderThreads(worktree.id);
-                                            }}
-                                            disabled={isWorktreePaging}
-                                          >
-                                            {isWorktreePaging
-                                              ? "Loading..."
-                                              : "Load older..."}
-                                          </button>
-                                        )}
+                                      })()}
                                     </div>
                                   )}
                                   {showWorktreeLoader && (
@@ -731,11 +811,14 @@ export function Sidebar({
                       )}
                       {showThreads && (
                         <div className="thread-list">
-                          {(expandedWorkspaces.has(entry.id)
-                            ? threads
-                            : threads.slice(0, 3)
-                          ).map((thread) => {
+                          {threadRows.map(({ thread, depth }) => {
                             const relativeTime = getThreadTime(thread);
+                            const indentStyle =
+                              depth > 0
+                                ? ({
+                                    "--thread-indent": `${depth * 14}px`,
+                                  } as CSSProperties)
+                                : undefined;
                             return (
                               <div
                                 key={thread.id}
@@ -744,7 +827,8 @@ export function Sidebar({
                                   thread.id === activeThreadId
                                     ? "active"
                                     : ""
-                                }`}
+                                  }`}
+                                style={indentStyle}
                                 onClick={() => onSelectThread(entry.id, thread.id)}
                                 onContextMenu={(event) =>
                                   showThreadMenu(event, entry.id, thread.id)
@@ -795,7 +879,7 @@ export function Sidebar({
                               </div>
                             );
                           })}
-                          {threads.length > 3 && (
+                          {totalThreadRoots > 3 && (
                             <button
                               className="thread-more"
                               onClick={(event) => {
@@ -811,12 +895,12 @@ export function Sidebar({
                                 });
                               }}
                             >
-                              {expandedWorkspaces.has(entry.id)
+                              {isExpanded
                                 ? "Show less"
                                 : "More..."}
                             </button>
                           )}
-                          {expandedWorkspaces.has(entry.id) && nextCursor && (
+                          {isExpanded && nextCursor && (
                             <button
                               className="thread-more"
                               onClick={(event) => {
diff --git a/src/features/layout/hooks/useLayoutNodes.tsx b/src/features/layout/hooks/useLayoutNodes.tsx
index 184f7337a..2d988f30f 100644
--- a/src/features/layout/hooks/useLayoutNodes.tsx
+++ b/src/features/layout/hooks/useLayoutNodes.tsx
@@ -66,6 +66,7 @@ type LayoutNodesOptions = {
   }>;
   hasWorkspaceGroups: boolean;
   threadsByWorkspace: Record<string, ThreadSummary[]>;
+  threadParentById: Record<string, string>;
   threadStatusById: Record<string, ThreadActivityStatus>;
   threadListLoadingByWorkspace: Record<string, boolean>;
   threadListPagingByWorkspace: Record<string, boolean>;
@@ -276,6 +277,7 @@ export function useLayoutNodes(options: LayoutNodesOptions): LayoutNodesResult {
       groupedWorkspaces={options.groupedWorkspaces}
       hasWorkspaceGroups={options.hasWorkspaceGroups}
       threadsByWorkspace={options.threadsByWorkspace}
+      threadParentById={options.threadParentById}
       threadStatusById={options.threadStatusById}
       threadListLoadingByWorkspace={options.threadListLoadingByWorkspace}
       threadListPagingByWorkspace={options.threadListPagingByWorkspace}
diff --git a/src/features/threads/hooks/useThreads.ts b/src/features/threads/hooks/useThreads.ts
index bc2cabdae..cfb497e8f 100644
--- a/src/features/threads/hooks/useThreads.ts
+++ b/src/features/threads/hooks/useThreads.ts
@@ -89,6 +89,14 @@ function asString(value: unknown) {
   return typeof value === "string" ? value : value ? String(value) : "";
 }
 
+function normalizeStringList(value: unknown) {
+  if (Array.isArray(value)) {
+    return value.map((entry) => asString(entry)).filter(Boolean);
+  }
+  const single = asString(value);
+  return single ? [single] : [];
+}
+
 function extractRpcErrorMessage(response: unknown) {
   if (!response || typeof response !== "object") {
     return null;
@@ -448,6 +456,84 @@ export function useThreads({
     }
   }, [onMessageActivity]);
 
+  const wouldCreateThreadCycle = useCallback(
+    (parentId: string, childId: string) => {
+      const visited = new Set([childId]);
+      let current: string | undefined = parentId;
+      while (current) {
+        if (visited.has(current)) {
+          return true;
+        }
+        visited.add(current);
+        current = state.threadParentById[current];
+      }
+      return false;
+    },
+    [state.threadParentById],
+  );
+
+  const updateThreadParent = useCallback(
+    (parentId: string, childIds: string[]) => {
+      if (!parentId || childIds.length === 0) {
+        return;
+      }
+      childIds.forEach((childId) => {
+        if (!childId || childId === parentId) {
+          return;
+        }
+        const existingParent = state.threadParentById[childId];
+        if (existingParent === parentId) {
+          return;
+        }
+        if (existingParent) {
+          return;
+        }
+        if (wouldCreateThreadCycle(parentId, childId)) {
+          return;
+        }
+        dispatch({ type: "setThreadParent", threadId: childId, parentId });
+      });
+    },
+    [state.threadParentById, wouldCreateThreadCycle],
+  );
+
+  const applyCollabThreadLinks = useCallback(
+    (fallbackThreadId: string, item: Record<string, unknown>) => {
+      const itemType = asString(item?.type ?? "");
+      if (itemType !== "collabToolCall" && itemType !== "collabAgentToolCall") {
+        return;
+      }
+      const sender = asString(item.senderThreadId ?? item.sender_thread_id ?? "");
+      const parentId = sender || fallbackThreadId;
+      if (!parentId) {
+        return;
+      }
+      const receivers = [
+        ...normalizeStringList(item.receiverThreadId ?? item.receiver_thread_id),
+        ...normalizeStringList(item.receiverThreadIds ?? item.receiver_thread_ids),
+        ...normalizeStringList(item.newThreadId ?? item.new_thread_id),
+      ];
+      updateThreadParent(parentId, receivers);
+    },
+    [updateThreadParent],
+  );
+
+  const applyCollabThreadLinksFromThread = useCallback(
+    (fallbackThreadId: string, thread: Record<string, unknown>) => {
+      const turns = Array.isArray(thread.turns) ? thread.turns : [];
+      turns.forEach((turn) => {
+        const turnRecord = turn as Record<string, unknown>;
+        const turnItems = Array.isArray(turnRecord.items)
+          ? (turnRecord.items as Record<string, unknown>[])
+          : [];
+        turnItems.forEach((item) => {
+          applyCollabThreadLinks(fallbackThreadId, item);
+        });
+      });
+    },
+    [applyCollabThreadLinks],
+  );
+
   const handleItemUpdate = useCallback(
     (
       workspaceId: string,
@@ -459,6 +545,7 @@ export function useThreads({
       if (shouldMarkProcessing) {
         markProcessing(threadId, true);
       }
+      applyCollabThreadLinks(threadId, item);
       const itemType = asString(item?.type ?? "");
       if (itemType === "enteredReviewMode") {
         dispatch({ type: "markReviewing", threadId, isReviewing: true });
@@ -472,7 +559,7 @@ export function useThreads({
       }
       safeMessageActivity();
     },
-    [markProcessing, safeMessageActivity],
+    [applyCollabThreadLinks, markProcessing, safeMessageActivity],
   );
 
   const handleToolOutputDelta = useCallback(
@@ -523,7 +610,7 @@ export function useThreads({
       }) => {
         dispatch({ type: "ensureThread", workspaceId, threadId });
         markProcessing(threadId, true);
-        dispatch({ type: "appendAgentDelta", threadId, itemId, delta });
+        dispatch({ type: "appendAgentDelta", workspaceId, threadId, itemId, delta });
       },
       onAgentMessageCompleted: ({
         workspaceId,
@@ -538,7 +625,13 @@ export function useThreads({
       }) => {
         const timestamp = Date.now();
         dispatch({ type: "ensureThread", workspaceId, threadId });
-        dispatch({ type: "completeAgentMessage", threadId, itemId, text });
+        dispatch({
+          type: "completeAgentMessage",
+          workspaceId,
+          threadId,
+          itemId,
+          text,
+        });
         dispatch({
           type: "setLastAgentMessage",
           threadId,
@@ -771,6 +864,7 @@ export function useThreads({
           | Record<string, unknown>
           | null;
         if (thread) {
+          applyCollabThreadLinksFromThread(threadId, thread);
           const items = buildItemsFromThread(thread);
           const localItems = state.itemsByThread[threadId] ?? [];
           const mergedItems =
@@ -823,7 +917,7 @@ export function useThreads({
         return null;
       }
     },
-    [onDebug, state.itemsByThread],
+    [applyCollabThreadLinksFromThread, onDebug, state.itemsByThread],
   );
 
   const listThreadsForWorkspace = useCallback(
@@ -1424,6 +1518,7 @@ export function useThreads({
     activeItems,
     approvals: state.approvals,
     threadsByWorkspace: state.threadsByWorkspace,
+    threadParentById: state.threadParentById,
     threadStatusById: state.threadStatusById,
     threadListLoadingByWorkspace: state.threadListLoadingByWorkspace,
     threadListPagingByWorkspace: state.threadListPagingByWorkspace,
diff --git a/src/features/threads/hooks/useThreadsReducer.ts b/src/features/threads/hooks/useThreadsReducer.ts
index b833354fc..69a9d5951 100644
--- a/src/features/threads/hooks/useThreadsReducer.ts
+++ b/src/features/threads/hooks/useThreadsReducer.ts
@@ -8,6 +8,82 @@ import type {
 } from "../../../types";
 import { normalizeItem, prepareThreadItems, upsertItem } from "../../../utils/threadItems";
 
+const MAX_THREAD_NAME_LENGTH = 38;
+
+function formatThreadName(text: string) {
+  const trimmed = text.trim();
+  if (!trimmed) {
+    return null;
+  }
+  return trimmed.length > MAX_THREAD_NAME_LENGTH
+    ? `${trimmed.slice(0, MAX_THREAD_NAME_LENGTH)}…`
+    : trimmed;
+}
+
+function getAssistantTextForRename(
+  items: ConversationItem[],
+  itemId?: string,
+): string {
+  if (itemId) {
+    const match = items.find(
+      (item) =>
+        item.kind === "message" &&
+        item.role === "assistant" &&
+        item.id === itemId,
+    );
+    if (match && match.kind === "message") {
+      return match.text;
+    }
+  }
+  for (let index = items.length - 1; index >= 0; index -= 1) {
+    const item = items[index];
+    if (item.kind === "message" && item.role === "assistant") {
+      return item.text;
+    }
+  }
+  return "";
+}
+
+function maybeRenameThreadFromAgent({
+  workspaceId,
+  threadId,
+  items,
+  itemId,
+  threadsByWorkspace,
+}: {
+  workspaceId: string;
+  threadId: string;
+  items: ConversationItem[];
+  itemId?: string;
+  threadsByWorkspace: Record<string, ThreadSummary[]>;
+}) {
+  const threads = threadsByWorkspace[workspaceId] ?? [];
+  if (!threads.length) {
+    return threadsByWorkspace;
+  }
+  const hasUserMessage = items.some(
+    (item) => item.kind === "message" && item.role === "user",
+  );
+  if (hasUserMessage) {
+    return threadsByWorkspace;
+  }
+  const nextName = formatThreadName(getAssistantTextForRename(items, itemId));
+  if (!nextName) {
+    return threadsByWorkspace;
+  }
+  let didChange = false;
+  const nextThreads = threads.map((thread) => {
+    if (thread.id !== threadId || thread.name === nextName) {
+      return thread;
+    }
+    didChange = true;
+    return { ...thread, name: nextName };
+  });
+  return didChange
+    ? { ...threadsByWorkspace, [workspaceId]: nextThreads }
+    : threadsByWorkspace;
+}
+
 type ThreadActivityStatus = {
   isProcessing: boolean;
   hasUnread: boolean;
@@ -20,6 +96,7 @@ export type ThreadState = {
   activeThreadIdByWorkspace: Record<string, string | null>;
   itemsByThread: Record<string, ConversationItem[]>;
   threadsByWorkspace: Record<string, ThreadSummary[]>;
+  threadParentById: Record<string, string>;
   threadStatusById: Record<string, ThreadActivityStatus>;
   threadListLoadingByWorkspace: Record<string, boolean>;
   threadListPagingByWorkspace: Record<string, boolean>;
@@ -36,6 +113,7 @@ export type ThreadAction =
   | { type: "setActiveThreadId"; workspaceId: string; threadId: string | null }
   | { type: "ensureThread"; workspaceId: string; threadId: string }
   | { type: "removeThread"; workspaceId: string; threadId: string }
+  | { type: "setThreadParent"; threadId: string; parentId: string }
   | {
       type: "markProcessing";
       threadId: string;
@@ -53,8 +131,20 @@ export type ThreadAction =
     }
   | { type: "addAssistantMessage"; threadId: string; text: string }
   | { type: "setThreadName"; workspaceId: string; threadId: string; name: string }
-  | { type: "appendAgentDelta"; threadId: string; itemId: string; delta: string }
-  | { type: "completeAgentMessage"; threadId: string; itemId: string; text: string }
+  | {
+      type: "appendAgentDelta";
+      workspaceId: string;
+      threadId: string;
+      itemId: string;
+      delta: string;
+    }
+  | {
+      type: "completeAgentMessage";
+      workspaceId: string;
+      threadId: string;
+      itemId: string;
+      text: string;
+    }
   | { type: "upsertItem"; threadId: string; item: ConversationItem }
   | { type: "setThreadItems"; threadId: string; items: ConversationItem[] }
   | {
@@ -105,6 +195,7 @@ export const initialState: ThreadState = {
   activeThreadIdByWorkspace: {},
   itemsByThread: emptyItems,
   threadsByWorkspace: {},
+  threadParentById: {},
   threadStatusById: {},
   threadListLoadingByWorkspace: {},
   threadListPagingByWorkspace: {},
@@ -213,6 +304,7 @@ export function threadReducer(state: ThreadState, action: ThreadAction): ThreadS
       const { [action.threadId]: __, ...restStatus } = state.threadStatusById;
       const { [action.threadId]: ___, ...restTurns } = state.activeTurnIdByThread;
       const { [action.threadId]: ____, ...restPlans } = state.planByThread;
+      const { [action.threadId]: _____, ...restParents } = state.threadParentById;
       return {
         ...state,
         threadsByWorkspace: {
@@ -223,12 +315,28 @@ export function threadReducer(state: ThreadState, action: ThreadAction): ThreadS
         threadStatusById: restStatus,
         activeTurnIdByThread: restTurns,
         planByThread: restPlans,
+        threadParentById: restParents,
         activeThreadIdByWorkspace: {
           ...state.activeThreadIdByWorkspace,
           [action.workspaceId]: nextActive,
         },
       };
     }
+    case "setThreadParent": {
+      if (!action.parentId || action.parentId === action.threadId) {
+        return state;
+      }
+      if (state.threadParentById[action.threadId] === action.parentId) {
+        return state;
+      }
+      return {
+        ...state,
+        threadParentById: {
+          ...state.threadParentById,
+          [action.threadId]: action.parentId,
+        },
+      };
+    }
     case "markProcessing": {
       const previous = state.threadStatusById[action.threadId];
       const wasProcessing = previous?.isProcessing ?? false;
@@ -413,12 +521,21 @@ export function threadReducer(state: ThreadState, action: ThreadAction): ThreadS
           text: action.delta,
         });
       }
+      const updatedItems = prepareThreadItems(list);
+      const nextThreadsByWorkspace = maybeRenameThreadFromAgent({
+        workspaceId: action.workspaceId,
+        threadId: action.threadId,
+        items: updatedItems,
+        itemId: action.itemId,
+        threadsByWorkspace: state.threadsByWorkspace,
+      });
       return {
         ...state,
         itemsByThread: {
           ...state.itemsByThread,
-          [action.threadId]: prepareThreadItems(list),
+          [action.threadId]: updatedItems,
         },
+        threadsByWorkspace: nextThreadsByWorkspace,
       };
     }
     case "completeAgentMessage": {
@@ -438,12 +555,21 @@ export function threadReducer(state: ThreadState, action: ThreadAction): ThreadS
           text: action.text,
         });
       }
+      const updatedItems = prepareThreadItems(list);
+      const nextThreadsByWorkspace = maybeRenameThreadFromAgent({
+        workspaceId: action.workspaceId,
+        threadId: action.threadId,
+        items: updatedItems,
+        itemId: action.itemId,
+        threadsByWorkspace: state.threadsByWorkspace,
+      });
       return {
         ...state,
         itemsByThread: {
           ...state.itemsByThread,
-          [action.threadId]: prepareThreadItems(list),
+          [action.threadId]: updatedItems,
         },
+        threadsByWorkspace: nextThreadsByWorkspace,
       };
     }
     case "upsertItem": {
diff --git a/src/styles/sidebar.css b/src/styles/sidebar.css
index 6a0ab44c8..674052125 100644
--- a/src/styles/sidebar.css
+++ b/src/styles/sidebar.css
@@ -394,7 +394,7 @@
   display: flex;
   align-items: center;
   gap: 6px;
-  padding: 4px 2px 4px 6px;
+  padding: 4px 2px 4px calc(6px + var(--thread-indent, 0px));
   border-radius: 6px;
   color: var(--text-quiet);
   font-size: 12px;