feat(threads): add thread read RPC and subagent metadata hydration

Author: Dimillian

src-tauri/src/bin/codex_monitor_daemon.rs

@@ -692,6 +692,14 @@ impl DaemonState {
         codex_core::resume_thread_core(&self.sessions, workspace_id, thread_id).await
     }
 
+    async fn read_thread(
+        &self,
+        workspace_id: String,
+        thread_id: String,
+    ) -> Result<Value, String> {
+        codex_core::read_thread_core(&self.sessions, workspace_id, thread_id).await
+    }
+
     async fn thread_live_subscribe(
         &self,
         workspace_id: String,

src-tauri/src/bin/codex_monitor_daemon/rpc/codex.rs

@@ -48,6 +48,17 @@ pub(super) async fn try_handle(
             };
             Some(state.resume_thread(workspace_id, thread_id).await)
         }
+        "read_thread" => {
+            let workspace_id = match parse_string(params, "workspaceId") {
+                Ok(value) => value,
+                Err(err) => return Some(Err(err)),
+            };
+            let thread_id = match parse_string(params, "threadId") {
+                Ok(value) => value,
+                Err(err) => return Some(Err(err)),
+            };
+            Some(state.read_thread(workspace_id, thread_id).await)
+        }
         "thread_live_subscribe" => {
             let workspace_id = match parse_string(params, "workspaceId") {
                 Ok(value) => value,

src-tauri/src/codex/mod.rs

@@ -110,6 +110,26 @@ pub(crate) async fn resume_thread(
     codex_core::resume_thread_core(&state.sessions, workspace_id, thread_id).await
 }
 
+#[tauri::command]
+pub(crate) async fn read_thread(
+    workspace_id: String,
+    thread_id: String,
+    state: State<'_, AppState>,
+    app: AppHandle,
+) -> Result<Value, String> {
+    if remote_backend::is_remote_mode(&*state).await {
+        return remote_backend::call_remote(
+            &*state,
+            app,
+            "read_thread",
+            json!({ "workspaceId": workspace_id, "threadId": thread_id }),
+        )
+        .await;
+    }
+
+    codex_core::read_thread_core(&state.sessions, workspace_id, thread_id).await
+}
+
 #[tauri::command]
 pub(crate) async fn thread_live_subscribe(
     workspace_id: String,

src-tauri/src/lib.rs

@@ -219,6 +219,7 @@ pub fn run() {
             codex::generate_run_metadata,
             codex::generate_agent_description,
             codex::resume_thread,
+            codex::read_thread,
             codex::thread_live_subscribe,
             codex::thread_live_unsubscribe,
             codex::fork_thread,

src-tauri/src/remote_backend/mod.rs

@@ -173,6 +173,7 @@ fn can_retry_after_disconnect(method: &str) -> bool {
             | "list_workspace_files"
             | "list_workspaces"
             | "model_list"
+            | "read_thread"
             | "read_agent_config_toml"
             | "read_workspace_file"
             | "resume_thread"

src-tauri/src/shared/codex_core.rs

@@ -276,6 +276,18 @@ pub(crate) async fn resume_thread_core(
         .await
 }
 
+pub(crate) async fn read_thread_core(
+    sessions: &Mutex<HashMap<String, Arc<WorkspaceSession>>>,
+    workspace_id: String,
+    thread_id: String,
+) -> Result<Value, String> {
+    let session = get_session_clone(sessions, &workspace_id).await?;
+    let params = json!({ "threadId": thread_id });
+    session
+        .send_request_for_workspace(&workspace_id, "thread/read", params)
+        .await
+}
+
 pub(crate) async fn thread_live_subscribe_core(
     sessions: &Mutex<HashMap<String, Arc<WorkspaceSession>>>,
     workspace_id: String,

src/features/threads/hooks/useThreadActions.ts

@@ -24,14 +24,11 @@ import {
   previewThreadName,
 } from "@utils/threadItems";
 import { extractThreadCodexMetadata } from "@threads/utils/threadCodexMetadata";
-import {
-  asString,
-  normalizeRootPath,
-} from "@threads/utils/threadNormalize";
+import { buildThreadSummaryFromThread } from "@threads/utils/threadSummary";
+import { asString, normalizeRootPath } from "@threads/utils/threadNormalize";
 import {
   getParentThreadIdFromThread,
   getResumedTurnState,
-  isSubagentThreadSource,
   shouldHideSubagentThreadFromSidebar,
 } from "@threads/utils/threadRpc";
 import { saveThreadActivity } from "@threads/utils/threadStorage";
@@ -113,20 +110,6 @@ function getThreadListNextCursor(result: Record<string, unknown>): string | null
   return null;
 }
 
-function getThreadSubagentMetadata(thread: Record<string, unknown>) {
-  const nickname =
-    asString(thread.agentNickname ?? thread.agent_nickname ?? "").trim() || null;
-  const role =
-    asString(
-      thread.agentRole ??
-        thread.agent_role ??
-        thread.agentType ??
-        thread.agent_type ??
-        "",
-    ).trim() || null;
-  return { nickname, role };
-}
-
 type UseThreadActionsOptions = {
   dispatch: Dispatch<ThreadAction>;
   itemsByThread: ThreadState["itemsByThread"];
@@ -521,43 +504,13 @@ export function useThreadActions({
       workspaceId: string,
       thread: Record<string, unknown>,
       fallbackIndex: number,
-    ): ThreadSummary | null => {
-      const id = String(thread?.id ?? "");
-      if (!id) {
-        return null;
-      }
-      const preview = asString(thread?.preview ?? "").trim();
-      const customName = getCustomName(workspaceId, id);
-      const fallbackName = `Agent ${fallbackIndex + 1}`;
-      const name = customName
-        ? customName
-        : preview.length > 0
-          ? preview.length > 38
-            ? `${preview.slice(0, 38)}…`
-            : preview
-          : fallbackName;
-      const metadata = extractThreadCodexMetadata(thread);
-      if (shouldHideSubagentThreadFromSidebar(thread.source)) {
-        return null;
-      }
-      const isSubagent = isSubagentThreadSource(thread.source);
-      const subagentMetadata = getThreadSubagentMetadata(thread);
-      return {
-        id,
-        name,
-        updatedAt: getThreadTimestamp(thread),
-        createdAt: getThreadCreatedTimestamp(thread),
-        ...(metadata.modelId ? { modelId: metadata.modelId } : {}),
-        ...(metadata.effort ? { effort: metadata.effort } : {}),
-        ...(isSubagent ? { isSubagent: true } : {}),
-        ...(isSubagent && subagentMetadata.nickname
-          ? { subagentNickname: subagentMetadata.nickname }
-          : {}),
-        ...(isSubagent && subagentMetadata.role
-          ? { subagentRole: subagentMetadata.role }
-          : {}),
-      };
-    },
+    ): ThreadSummary | null =>
+      buildThreadSummaryFromThread({
+        workspaceId,
+        thread,
+        fallbackIndex,
+        getCustomName,
+      }),
     [getCustomName],
   );
 

src/features/threads/hooks/useThreadEventHandlers.ts

@@ -2,6 +2,7 @@ import { useCallback, useMemo } from "react";
 import type { Dispatch, MutableRefObject } from "react";
 import type {
   AppServerEvent,
+  CollabAgentRef,
   ConversationItem,
   DebugEntry,
   RateLimitSnapshot,
@@ -47,6 +48,10 @@ type ThreadEventHandlersOptions = {
     threadId: string,
     item: Record<string, unknown>,
   ) => void;
+  hydrateSubagentThreads?: (
+    workspaceId: string,
+    receivers: CollabAgentRef[],
+  ) => void | Promise<void>;
   onReviewExited?: (workspaceId: string, threadId: string) => void;
   approvalAllowlistRef: MutableRefObject<Record<string, string[][]>>;
   pendingInterruptsRef: MutableRefObject<Set<string>>;
@@ -72,6 +77,7 @@ export function useThreadEventHandlers({
   onDebug,
   onWorkspaceConnected,
   applyCollabThreadLinks,
+  hydrateSubagentThreads,
   onReviewExited,
   approvalAllowlistRef,
   pendingInterruptsRef,
@@ -143,6 +149,7 @@ export function useThreadEventHandlers({
     safeMessageActivity,
     recordThreadActivity,
     applyCollabThreadLinks,
+    hydrateSubagentThreads,
     onUserMessageCreated,
     onReviewExited,
   });

src/features/threads/hooks/useThreadItemEvents.ts

@@ -1,6 +1,7 @@
 import { useCallback } from "react";
 import type { Dispatch } from "react";
 import { buildConversationItem } from "@utils/threadItems";
+import type { CollabAgentRef } from "@/types";
 import { asString } from "@threads/utils/threadNormalize";
 import type { ThreadAction } from "./useThreadsReducer";
 
@@ -21,6 +22,10 @@ type UseThreadItemEventsOptions = {
     threadId: string,
     item: Record<string, unknown>,
   ) => void;
+  hydrateSubagentThreads?: (
+    workspaceId: string,
+    receivers: CollabAgentRef[],
+  ) => void | Promise<void>;
   onUserMessageCreated?: (
     workspaceId: string,
     threadId: string,
@@ -38,6 +43,7 @@ export function useThreadItemEvents({
   safeMessageActivity,
   recordThreadActivity,
   applyCollabThreadLinks,
+  hydrateSubagentThreads,
   onUserMessageCreated,
   onReviewExited,
 }: UseThreadItemEventsOptions) {
@@ -72,6 +78,20 @@ export function useThreadItemEvents({
           : item;
       const converted = buildConversationItem(itemForDisplay);
       if (converted) {
+        if (converted.kind === "tool" && converted.toolType === "collabToolCall") {
+          const receivers = converted.collabReceivers?.length
+            ? converted.collabReceivers
+            : converted.collabReceiver
+              ? [converted.collabReceiver]
+              : [];
+          const hydrationTargets = receivers.filter(
+            (receiver) =>
+              receiver.threadId && (!receiver.nickname || !receiver.role),
+          );
+          if (hydrationTargets.length > 0) {
+            void hydrateSubagentThreads?.(workspaceId, hydrationTargets);
+          }
+        }
         if (converted.kind === "message" && converted.role === "user") {
           void onUserMessageCreated?.(workspaceId, threadId, converted.text);
         }
@@ -93,6 +113,7 @@ export function useThreadItemEvents({
       markReviewing,
       onReviewExited,
       onUserMessageCreated,
+      hydrateSubagentThreads,
       safeMessageActivity,
     ],
   );

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

@@ -18,6 +18,7 @@ describe("useThreadSelectors", () => {
         activeWorkspaceId: "workspace-1",
         activeThreadIdByWorkspace: { "workspace-1": "thread-1" },
         itemsByThread: { "thread-1": [messageItem] },
+        threadsByWorkspace: {},
       }),
     );
 
@@ -31,6 +32,7 @@ describe("useThreadSelectors", () => {
         activeWorkspaceId: null,
         activeThreadIdByWorkspace: { "workspace-1": "thread-1" },
         itemsByThread: { "thread-1": [messageItem] },
+        threadsByWorkspace: {},
       }),
     );
 
@@ -44,10 +46,75 @@ describe("useThreadSelectors", () => {
         activeWorkspaceId: "workspace-1",
         activeThreadIdByWorkspace: { "workspace-1": "thread-2" },
         itemsByThread: {},
+        threadsByWorkspace: {},
       }),
     );
 
     expect(result.current.activeThreadId).toBe("thread-2");
     expect(result.current.activeItems).toEqual([]);
   });
+
+  it("enriches collab tool items from active workspace thread metadata", () => {
+    const collabItem: ConversationItem = {
+      id: "collab-1",
+      kind: "tool",
+      toolType: "collabToolCall",
+      title: "Collab: spawn_agent",
+      detail: "From thread-parent → thread-child",
+      status: "completed",
+      output: "Investigate the issue\n\nthread-child: completed",
+      collabSender: { threadId: "thread-parent" },
+      collabReceiver: { threadId: "thread-child" },
+      collabReceivers: [{ threadId: "thread-child" }],
+      collabStatuses: [{ threadId: "thread-child", status: "completed" }],
+    };
+
+    const { result } = renderHook(() =>
+      useThreadSelectors({
+        activeWorkspaceId: "workspace-1",
+        activeThreadIdByWorkspace: { "workspace-1": "thread-parent" },
+        itemsByThread: { "thread-parent": [collabItem] },
+        threadsByWorkspace: {
+          "workspace-1": [
+            {
+              id: "thread-child",
+              name: "Review helper",
+              updatedAt: 1,
+              isSubagent: true,
+              subagentNickname: "Atlas",
+              subagentRole: "reviewer",
+            },
+          ],
+        },
+      }),
+    );
+
+    expect(result.current.activeItems).toEqual([
+      {
+        ...collabItem,
+        detail: "From thread-parent → Atlas [reviewer]",
+        output: "Investigate the issue\n\nAtlas [reviewer]: completed",
+        collabReceiver: {
+          threadId: "thread-child",
+          nickname: "Atlas",
+          role: "reviewer",
+        },
+        collabReceivers: [
+          {
+            threadId: "thread-child",
+            nickname: "Atlas",
+            role: "reviewer",
+          },
+        ],
+        collabStatuses: [
+          {
+            threadId: "thread-child",
+            nickname: "Atlas",
+            role: "reviewer",
+            status: "completed",
+          },
+        ],
+      },
+    ]);
+  });
 });