feat: enrich collab sub-agent metadata rendering (#474)

Author: Dimillian

src/features/messages/utils/messageRenderUtils.test.ts

@@ -41,4 +41,27 @@ describe("messageRenderUtils", () => {
   it("classifies camelCase inProgress as processing", () => {
     expect(statusToneFromText("inProgress")).toBe("processing");
   });
+
+  it("renders collab tool calls with nickname and role", () => {
+    const summary = buildToolSummary(
+      makeToolItem({
+        toolType: "collabToolCall",
+        title: "Collab: wait",
+        detail: "From thread-parent → thread-child",
+        status: "completed",
+        output: "Robie [explorer]: completed",
+        collabReceivers: [
+          {
+            threadId: "thread-child",
+            nickname: "Robie",
+            role: "explorer",
+          },
+        ],
+      }),
+      "",
+    );
+    expect(summary.label).toBe("waited for");
+    expect(summary.value).toBe("Robie [explorer]");
+    expect(summary.output).toContain("Robie [explorer]: completed");
+  });
 });

src/features/messages/utils/messageRenderUtils.ts

@@ -77,6 +77,64 @@ function firstStringField(
   return "";
 }
 
+function formatCollabAgentLabel(agent: {
+  threadId: string;
+  nickname?: string;
+  role?: string;
+}) {
+  const nickname = agent.nickname?.trim();
+  const role = agent.role?.trim();
+  if (nickname && role) {
+    return `${nickname} [${role}]`;
+  }
+  if (nickname) {
+    return nickname;
+  }
+  if (role) {
+    return `${agent.threadId} [${role}]`;
+  }
+  return agent.threadId;
+}
+
+function summarizeCollabLabel(title: string, status?: string) {
+  const tool = title.replace(/^collab:\s*/i, "").trim().toLowerCase();
+  const tone = statusToneFromText(status);
+  if (tool.includes("wait")) {
+    return tone === "processing" ? "waiting for" : "waited for";
+  }
+  if (tool.includes("resume")) {
+    return tone === "processing" ? "resuming" : "resumed";
+  }
+  if (tool.includes("close")) {
+    return tone === "processing" ? "closing" : "closed";
+  }
+  if (tool.includes("spawn")) {
+    return tone === "processing" ? "spawning" : "spawned";
+  }
+  if (tool.includes("send") || tool.includes("interaction")) {
+    return tone === "processing" ? "sending to" : "sent to";
+  }
+  return "sub-agent";
+}
+
+function summarizeCollabReceiver(
+  item: Extract<ConversationItem, { kind: "tool" }>,
+) {
+  const receivers =
+    item.collabReceivers && item.collabReceivers.length > 0
+      ? item.collabReceivers
+      : item.collabReceiver
+        ? [item.collabReceiver]
+        : [];
+  if (receivers.length === 0) {
+    return item.title || "";
+  }
+  if (receivers.length === 1) {
+    return formatCollabAgentLabel(receivers[0]);
+  }
+  return `${formatCollabAgentLabel(receivers[0])} +${receivers.length - 1}`;
+}
+
 export function toolNameFromTitle(title: string) {
   if (!title.toLowerCase().startsWith("tool:")) {
     return "";
@@ -302,6 +360,15 @@ export function buildToolSummary(
     };
   }
 
+  if (item.toolType === "collabToolCall") {
+    return {
+      label: summarizeCollabLabel(item.title, item.status),
+      value: summarizeCollabReceiver(item),
+      detail: item.detail || "",
+      output: item.output || "",
+    };
+  }
+
   if (item.toolType === "mcpToolCall") {
     const toolName = toolNameFromTitle(item.title);
     const args = parseToolArgs(item.detail);

src/features/threads/hooks/useThreadLinking.ts

@@ -9,6 +9,49 @@ type UseThreadLinkingOptions = {
   onSubagentThreadDetected?: (workspaceId: string, threadId: string) => void;
 };
 
+function normalizeThreadId(value: unknown) {
+  return asString(value).trim();
+}
+
+function normalizeThreadIdsFromAgentRefs(value: unknown) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return value
+    .map((entry) => {
+      if (!entry || typeof entry !== "object") {
+        return "";
+      }
+      const record = entry as Record<string, unknown>;
+      return normalizeThreadId(record.threadId ?? record.thread_id ?? record.id);
+    })
+    .filter(Boolean);
+}
+
+function normalizeThreadIdsFromAgentStatuses(value: unknown) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return value
+    .map((entry) => {
+      if (!entry || typeof entry !== "object") {
+        return "";
+      }
+      const record = entry as Record<string, unknown>;
+      return normalizeThreadId(record.threadId ?? record.thread_id ?? record.id);
+    })
+    .filter(Boolean);
+}
+
+function normalizeThreadIdsFromStatusMap(value: unknown) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return [];
+  }
+  return Object.keys(value as Record<string, unknown>)
+    .map((key) => normalizeThreadId(key))
+    .filter(Boolean);
+}
+
 export function useThreadLinking({
   dispatch,
   threadParentById,
@@ -70,11 +113,18 @@ export function useThreadLinking({
       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),
-      ];
+      const receivers = Array.from(
+        new Set([
+          ...normalizeStringList(item.receiverThreadId ?? item.receiver_thread_id),
+          ...normalizeStringList(item.receiverThreadIds ?? item.receiver_thread_ids),
+          ...normalizeStringList(item.newThreadId ?? item.new_thread_id),
+          ...normalizeThreadIdsFromAgentRefs(item.receiverAgents ?? item.receiver_agents),
+          ...normalizeThreadIdsFromAgentStatuses(
+            item.agentStatuses ?? item.agent_statuses,
+          ),
+          ...normalizeThreadIdsFromStatusMap(item.statuses),
+        ]),
+      );
       updateThreadParent(parentId, receivers);
       receivers.forEach((receiver) => {
         if (!receiver) {

src/features/threads/hooks/useThreads.integration.test.tsx

@@ -1121,6 +1121,37 @@ describe("useThreads UX integration", () => {
     expect(result.current.isSubagentThread("ws-1", "thread-child-live-collab")).toBe(true);
   });
 
+  it("classifies collab receivers from receiver_agents metadata", () => {
+    const { result } = renderHook(() =>
+      useThreads({
+        activeWorkspace: workspace,
+        onWorkspaceConnected: vi.fn(),
+      }),
+    );
+
+    act(() => {
+      handlers?.onItemCompleted?.("ws-1", "thread-parent-live", {
+        type: "collabToolCall",
+        id: "item-collab-receiver-agents",
+        sender_thread_id: "thread-parent-live",
+        receiver_agents: [
+          {
+            thread_id: "thread-child-live-agent-ref",
+            agent_nickname: "Robie",
+            agent_role: "explorer",
+          },
+        ],
+      });
+    });
+
+    expect(result.current.threadParentById["thread-child-live-agent-ref"]).toBe(
+      "thread-parent-live",
+    );
+    expect(result.current.isSubagentThread("ws-1", "thread-child-live-agent-ref")).toBe(
+      true,
+    );
+  });
+
   it("cascades archive to subagent descendants when parent archived", async () => {
     const { result } = renderHook(() =>
       useThreads({

src/types.ts

@@ -71,6 +71,16 @@ export type Message = {
   text: string;
 };
 
+export type CollabAgentRef = {
+  threadId: string;
+  nickname?: string;
+  role?: string;
+};
+
+export type CollabAgentStatus = CollabAgentRef & {
+  status: string;
+};
+
 export type ConversationItem =
   | {
       id: string;
@@ -98,6 +108,10 @@ export type ConversationItem =
       output?: string;
       durationMs?: number | null;
       changes?: { path: string; kind?: string; diff?: string }[];
+      collabSender?: CollabAgentRef;
+      collabReceiver?: CollabAgentRef;
+      collabReceivers?: CollabAgentRef[];
+      collabStatuses?: CollabAgentStatus[];
     };
 
 export type ThreadSummary = {

src/utils/threadItems.test.ts

@@ -682,11 +682,65 @@ describe("threadItems", () => {
     if (item && item.kind === "tool") {
       expect(item.title).toBe("Collab: handoff");
       expect(item.detail).toContain("From thread-a");
-      expect(item.detail).toContain("thread-b, thread-c");
+      expect(item.detail).toContain("thread-b");
+      expect(item.detail).toContain("thread-c");
       expect(item.output).toBe("Coordinate work\n\nagent-1: running");
     }
   });
 
+  it("captures rich collab metadata from receiver_agents and agent_statuses", () => {
+    const item = buildConversationItem({
+      type: "collabToolCall",
+      id: "collab-rich-1",
+      tool: "wait",
+      status: "completed",
+      sender_thread_id: "thread-parent",
+      receiver_agents: [
+        {
+          thread_id: "thread-child-1",
+          agent_nickname: "Robie",
+          agent_role: "explorer",
+        },
+      ],
+      agent_statuses: [
+        {
+          thread_id: "thread-child-1",
+          status: "completed",
+          agent_nickname: "Robie",
+          agent_role: "explorer",
+        },
+      ],
+      prompt: "Wait for workers",
+    });
+
+    expect(item).not.toBeNull();
+    if (item && item.kind === "tool") {
+      expect(item.collabSender).toEqual({ threadId: "thread-parent" });
+      expect(item.collabReceiver).toEqual({
+        threadId: "thread-child-1",
+        nickname: "Robie",
+        role: "explorer",
+      });
+      expect(item.collabReceivers).toEqual([
+        {
+          threadId: "thread-child-1",
+          nickname: "Robie",
+          role: "explorer",
+        },
+      ]);
+      expect(item.collabStatuses).toEqual([
+        {
+          threadId: "thread-child-1",
+          nickname: "Robie",
+          role: "explorer",
+          status: "completed",
+        },
+      ]);
+      expect(item.detail).toContain("Robie [explorer]");
+      expect(item.output).toContain("Robie [explorer]: completed");
+    }
+  });
+
   it("builds context compaction items", () => {
     const item = buildConversationItem({
       type: "contextCompaction",