fix(threads): share thread naming utilities and review auto-renames

Author: Dimillian

src/features/threads/hooks/threadReducer/common.ts

@@ -1,21 +1,7 @@
 import type { ConversationItem } from "@/types";
 import type { ThreadState } from "../useThreadsReducer";
-
-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;
-}
-
-export function looksAutoGeneratedThreadName(name: string) {
-  return name === "New Agent" || name.startsWith("Agent ") || /^[a-f0-9]{4,8}$/i.test(name);
-}
+import { clampThreadName, looksAutoGeneratedThreadName } from "@threads/utils/threadNaming";
+export { looksAutoGeneratedThreadName } from "@threads/utils/threadNaming";
 
 export function extractRenameText(text: string) {
   if (!text) {
@@ -78,7 +64,7 @@ export function maybeRenameThreadFromAgent({
   if (hasCustomName) {
     return threadsByWorkspace;
   }
-  const nextName = formatThreadName(getAssistantTextForRename(items, itemId));
+  const nextName = clampThreadName(getAssistantTextForRename(items, itemId));
   if (!nextName) {
     return threadsByWorkspace;
   }

src/features/threads/hooks/useThreadMessaging.test.tsx

@@ -487,4 +487,58 @@ describe("useThreadMessaging telemetry", () => {
       "Turn steer failed: steer network failure",
     );
   });
+
+  it("names detached commit review child threads from commit context", async () => {
+    vi.mocked(startReviewService).mockResolvedValueOnce({
+      result: {
+        review_thread_id: "thread-review-1",
+      },
+    } as unknown as Awaited<ReturnType<typeof startReviewService>>);
+    const renameThread = vi.fn();
+
+    const { result } = renderHook(() =>
+      useThreadMessaging({
+        activeWorkspace: workspace,
+        activeThreadId: "thread-parent",
+        accessMode: "current",
+        model: null,
+        effort: null,
+        collaborationMode: null,
+        reviewDeliveryMode: "detached",
+        steerEnabled: false,
+        customPrompts: [],
+        threadStatusById: {},
+        activeTurnIdByThread: {},
+        rateLimitsByWorkspace: {},
+        pendingInterruptsRef: { current: new Set<string>() },
+        dispatch: vi.fn(),
+        getCustomName: vi.fn(() => undefined),
+        markProcessing: vi.fn(),
+        markReviewing: vi.fn(),
+        setActiveTurnId: vi.fn(),
+        recordThreadActivity: vi.fn(),
+        safeMessageActivity: vi.fn(),
+        onDebug: vi.fn(),
+        pushThreadErrorMessage: vi.fn(),
+        ensureThreadForActiveWorkspace: vi.fn(async () => "thread-parent"),
+        ensureThreadForWorkspace: vi.fn(async () => "thread-parent"),
+        refreshThread: vi.fn(async () => null),
+        forkThreadForWorkspace: vi.fn(async () => null),
+        updateThreadParent: vi.fn(),
+        renameThread,
+      }),
+    );
+
+    await act(async () => {
+      await result.current.startReview(
+        "/review commit abcdef1234567890 Tighten sidebar commit selection",
+      );
+    });
+
+    expect(renameThread).toHaveBeenCalledWith(
+      "ws-1",
+      "thread-review-1",
+      "Review abcdef1: Tighten sidebar commit…",
+    );
+  });
 });

src/features/threads/hooks/useThreadMessaging.ts

@@ -28,6 +28,7 @@ import {
   extractRpcErrorMessage,
   parseReviewTarget,
 } from "@threads/utils/threadNormalize";
+import { clampThreadName } from "@threads/utils/threadNaming";
 import type { ThreadAction, ThreadState } from "./useThreadsReducer";
 import { useReviewPrompt } from "./useReviewPrompt";
 import { formatRelativeTime } from "@utils/time";
@@ -91,8 +92,30 @@ type UseThreadMessagingOptions = {
     parentId: string,
     childId: string,
   ) => void;
+  renameThread?: (workspaceId: string, threadId: string, name: string) => void;
 };
 
+function buildReviewThreadTitle(target: ReviewTarget): string | null {
+  if (target.type === "commit") {
+    const shortSha = target.sha.trim().slice(0, 7);
+    const title = target.title?.trim() ?? "";
+    if (shortSha && title) {
+      return clampThreadName(`Review ${shortSha}: ${title}`);
+    }
+    if (shortSha) {
+      return clampThreadName(`Review ${shortSha}`);
+    }
+    return clampThreadName("Review Commit");
+  }
+  if (target.type === "baseBranch") {
+    return clampThreadName(`Review ${target.branch}`);
+  }
+  if (target.type === "uncommittedChanges") {
+    return "Review Working Tree";
+  }
+  return null;
+}
+
 function isStaleSteerTurnError(message: string): boolean {
   const normalized = message.trim().toLowerCase();
   if (!normalized) {
@@ -135,6 +158,7 @@ export function useThreadMessaging({
   forkThreadForWorkspace,
   updateThreadParent,
   registerDetachedReviewChild,
+  renameThread,
 }: UseThreadMessagingOptions) {
   const sendMessageToThread = useCallback(
     async (
@@ -568,6 +592,10 @@ export function useThreadMessaging({
           updateThreadParent(threadId, [reviewThreadId]);
           if (reviewDeliveryMode === "detached") {
             registerDetachedReviewChild?.(workspaceId, threadId, reviewThreadId);
+            const reviewTitle = buildReviewThreadTitle(target);
+            if (reviewTitle && !getCustomName(workspaceId, reviewThreadId)) {
+              renameThread?.(workspaceId, reviewThreadId, reviewTitle);
+            }
           }
         }
         return true;
@@ -595,6 +623,7 @@ export function useThreadMessaging({
       activeWorkspace,
       ensureThreadForActiveWorkspace,
       ensureThreadForWorkspace,
+      getCustomName,
       markProcessing,
       markReviewing,
       onDebug,
@@ -603,6 +632,7 @@ export function useThreadMessaging({
       setActiveTurnId,
       reviewDeliveryMode,
       registerDetachedReviewChild,
+      renameThread,
       updateThreadParent,
     ],
   );

src/features/threads/hooks/useThreadTitleAutogeneration.test.tsx

@@ -109,6 +109,23 @@ describe("useThreadTitleAutogeneration", () => {
     expect(generateRunMetadata).not.toHaveBeenCalled();
   });
 
+  it("treats UUID placeholder thread names as auto-generated", async () => {
+    vi.mocked(generateRunMetadata).mockResolvedValue({
+      title: "Commit review summary",
+      worktreeName: "feat/review-summary",
+    });
+    const { result, renameThread } = setup({
+      threadName: "019c9e0e-7f97-78f2-a719-d28af9fb76b6",
+    });
+
+    await act(async () => {
+      await result.current.onUserMessageCreated("ws-1", "thread-1", "Review this commit");
+    });
+
+    expect(generateRunMetadata).toHaveBeenCalledWith("ws-1", "Review this commit");
+    expect(renameThread).toHaveBeenCalledWith("ws-1", "thread-1", "Commit review summary");
+  });
+
   it("avoids duplicate generation while in flight", async () => {
     let resolvePromise!: (value: { title: string; worktreeName: string }) => void;
     const pending = new Promise<{ title: string; worktreeName: string }>((resolve) => {

src/features/threads/hooks/useThreadTitleAutogeneration.ts

@@ -2,28 +2,10 @@ import { useCallback, useRef } from "react";
 import type { MutableRefObject } from "react";
 import type { ConversationItem, DebugEntry, ThreadSummary } from "@/types";
 import { generateRunMetadata } from "@services/tauri";
+import { clampThreadName, looksAutoGeneratedThreadName } from "@threads/utils/threadNaming";
 
-const MAX_THREAD_NAME_LENGTH = 38;
 const MAX_PROMPT_CHARS = 1200;
 
-function looksAutoGeneratedThreadName(name: string) {
-  return (
-    name === "New Agent" ||
-    name.startsWith("Agent ") ||
-    /^[a-f0-9]{4,8}$/i.test(name)
-  );
-}
-
-function clampThreadTitle(title: string) {
-  const trimmed = title.replace(/\s+/g, " ").trim();
-  if (!trimmed) {
-    return null;
-  }
-  return trimmed.length > MAX_THREAD_NAME_LENGTH
-    ? `${trimmed.slice(0, MAX_THREAD_NAME_LENGTH)}…`
-    : trimmed;
-}
-
 function cleanPromptText(text: string) {
   if (!text) {
     return "";
@@ -93,7 +75,7 @@ export function useThreadTitleAutogeneration({
       inFlightRef.current[key] = true;
       try {
         const metadata = await generateRunMetadata(workspaceId, cleaned);
-        const title = clampThreadTitle(metadata.title ?? "");
+        const title = clampThreadName(metadata.title ?? "");
         if (!title) {
           return;
         }
@@ -125,4 +107,3 @@ export function useThreadTitleAutogeneration({
 
   return { onUserMessageCreated };
 }
-

src/features/threads/hooks/useThreadTurnEvents.test.tsx

@@ -256,6 +256,26 @@ describe("useThreadTurnEvents", () => {
     });
   });
 
+  it("ignores placeholder thread names that mirror the thread id", () => {
+    const { result, dispatch, getCustomName } = makeOptions();
+    getCustomName.mockReturnValue(undefined);
+
+    act(() => {
+      result.current.onThreadNameUpdated("ws-1", {
+        threadId: "019c9e0e-7f97-78f2-a719-d28af9fb76b6",
+        threadName: "019c9e0e-7f97-78f2-a719-d28af9fb76b6",
+      });
+    });
+
+    expect(dispatch).not.toHaveBeenCalledWith(
+      expect.objectContaining({
+        type: "setThreadName",
+        workspaceId: "ws-1",
+        threadId: "019c9e0e-7f97-78f2-a719-d28af9fb76b6",
+      }),
+    );
+  });
+
   it("does not override custom thread names on thread name updated", () => {
     const { result, dispatch, getCustomName } = makeOptions();
     getCustomName.mockReturnValue("Custom Name");

src/features/threads/hooks/useThreadTurnEvents.ts

@@ -9,6 +9,7 @@ import {
   normalizeRateLimits,
   normalizeTokenUsage,
 } from "@threads/utils/threadNormalize";
+import { looksAutoGeneratedThreadName } from "@threads/utils/threadNaming";
 import {
   getParentThreadIdFromThread,
   isSubagentThreadSource,
@@ -159,14 +160,22 @@ export function useThreadTurnEvents({
       if (!threadId || !threadName) {
         return;
       }
+      const normalizedThreadId = threadId.trim().toLowerCase();
+      const normalizedThreadName = threadName.trim();
+      if (
+        normalizedThreadName.toLowerCase() === normalizedThreadId &&
+        looksAutoGeneratedThreadName(normalizedThreadName)
+      ) {
+        return;
+      }
       if (getCustomName(workspaceId, threadId)) {
         return;
       }
       dispatch({
         type: "setThreadName",
         workspaceId,
         threadId,
-        name: threadName,
+        name: normalizedThreadName,
       });
     },
     [dispatch, getCustomName],

src/features/threads/hooks/useThreads.ts

@@ -763,6 +763,7 @@ export function useThreads({
     forkThreadForWorkspace,
     updateThreadParent,
     registerDetachedReviewChild,
+    renameThread,
   });
 
   const hasLocalThreadSnapshot = useCallback(

src/features/threads/utils/threadNaming.ts

@@ -0,0 +1,24 @@
+const UUID_LIKE_THREAD_NAME_REGEX =
+  /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+
+const SHORT_HEX_THREAD_NAME_REGEX = /^[a-f0-9]{4,8}$/i;
+
+export function looksAutoGeneratedThreadName(name: string) {
+  const trimmed = name.trim();
+  return (
+    trimmed === "New Agent" ||
+    trimmed.startsWith("Agent ") ||
+    SHORT_HEX_THREAD_NAME_REGEX.test(trimmed) ||
+    UUID_LIKE_THREAD_NAME_REGEX.test(trimmed)
+  );
+}
+
+export function clampThreadName(name: string, maxLength = 38): string | null {
+  const trimmed = name.replace(/\s+/g, " ").trim();
+  if (!trimmed) {
+    return null;
+  }
+  return trimmed.length > maxLength
+    ? `${trimmed.slice(0, maxLength)}…`
+    : trimmed;
+}