@vertesia/ui 1.5.0-dev.20260807.073259Z → 1.5.0-dev.20260901.005903Z

package/src/features/agent/chat/ModernAgentConversation.test.tsx

@@ -3,6 +3,7 @@ import { type AgentMessage, AgentMessageType, type ConversationFile, FileProcess
 import type React from 'react';
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import { renderWithProviders } from '../../../__tests__/test-utils.js';
+import { ToastContext } from '../../../core/components/toast/ToastContext.js';
 import { ModernAgentConversation } from './ModernAgentConversation';
 
 const mocks = vi.hoisted(() => ({
@@ -12,6 +13,7 @@ const mocks = vi.hoisted(() => ({
     reconnect: vi.fn(),
     restart: vi.fn(),
     sendSignal: vi.fn(),
+    uploadArtifact: vi.fn(),
     headerProps: vi.fn(),
     allMessagesMixedProps: vi.fn(),
     messageInputProps: vi.fn(),
@@ -30,6 +32,7 @@ vi.mock('@vertesia/ui/session', () => ({
             agents: {
                 restart: mocks.restart,
                 sendSignal: mocks.sendSignal,
+                uploadArtifact: mocks.uploadArtifact,
                 getActiveWorkstreams: mocks.getActiveWorkstreams,
                 retrieve: mocks.retrieve,
             },
@@ -261,6 +264,7 @@ describe('ModernAgentConversation send handling', () => {
         window.sessionStorage.clear();
         mocks.restart.mockResolvedValue({ id: 'agent-run-1' });
         mocks.sendSignal.mockResolvedValue({});
+        mocks.uploadArtifact.mockResolvedValue({});
         mocks.getActiveWorkstreams.mockResolvedValue({ running: [] });
         mocks.retrieve.mockResolvedValue({ disabled_mcp_collections: undefined });
         mocks.useAgentPlans.mockReturnValue({
@@ -501,6 +505,162 @@ describe('ModernAgentConversation send handling', () => {
         });
     });
 
+    describe('files staged before the run existed', () => {
+        // Staging must upload inline in StartWorkflowView, not via a handoff to the conversation
+        // view: consumers like StudioAssistantPanel feed the new agentRunId straight back as a
+        // prop, which unmounts StartWorkflowView (and any handoff state) the moment the run
+        // starts. Regression coverage for the flow where staged files silently vanished.
+        it('uploads staged files, closes the batch with a manifest, and sends no follow-up message', async () => {
+            const startWorkflow = vi.fn().mockResolvedValue({ agent_run_id: 'agent-run-2' });
+            mockStreamState({
+                messages: [],
+                isCompleted: false,
+                initialHistoryStatus: 'empty',
+                agentRunStatus: 'RUNNING',
+            });
+
+            const { container } = renderWithProviders(
+                <ModernAgentConversation startWorkflow={startWorkflow} hideHeader initialMessage="" />,
+            );
+
+            const file = new File(['pdf'], 'report.pdf', { type: 'application/pdf' });
+            const fileInput = container.querySelector('input[type="file"]') as HTMLInputElement;
+            expect(fileInput).not.toBeNull();
+            fireEvent.change(fileInput, { target: { files: [file] } });
+
+            fireEvent.change(screen.getByRole('textbox'), { target: { value: 'Look at these files' } });
+            fireEvent.click(screen.getByRole('button', { name: 'Start Agent' }));
+
+            await waitFor(() => {
+                expect(mocks.uploadArtifact).toHaveBeenCalledWith('agent-run-2', 'files/report.pdf', file);
+            });
+            await waitFor(() => {
+                expect(mocks.sendSignal).toHaveBeenCalledWith(
+                    'agent-run-2',
+                    'FileUploaded',
+                    expect.objectContaining({
+                        name: 'report.pdf',
+                        artifact_path: 'files/report.pdf',
+                    }),
+                );
+            });
+
+            // The closing manifest defines the batch's membership: the workflow delivers only
+            // when every listed file has settled, so a fast first file can never trigger a
+            // partial delivery.
+            const uploadedCall = mocks.sendSignal.mock.calls.find((call) => call[1] === 'FileUploaded');
+            const uploadedId = (uploadedCall?.[2] as { id?: string } | undefined)?.id;
+            expect(uploadedId).toEqual(expect.stringMatching(/^file-/));
+            await waitFor(() => {
+                expect(mocks.sendSignal).toHaveBeenCalledWith(
+                    'agent-run-2',
+                    'FileBatchClosed',
+                    expect.objectContaining({
+                        batch_id: expect.stringMatching(/^batch-/),
+                        file_ids: [uploadedId],
+                    }),
+                );
+            });
+
+            // The workflow owns the "[Files Ready]" turn: the client must not send a UserInput
+            // of its own — it would race the workflow's delivery.
+            const userInputCalls = mocks.sendSignal.mock.calls.filter((call) => call[1] === 'UserInput');
+            expect(userInputCalls).toHaveLength(0);
+
+            // The staged note still rides on the initial message so the agent knows to wait.
+            expect(startWorkflow).toHaveBeenCalledWith(
+                expect.stringContaining('1 file(s) are being uploaded'),
+                expect.anything(),
+            );
+        });
+
+        it('carries client-side upload failures in the manifest', async () => {
+            const startWorkflow = vi.fn().mockResolvedValue({ agent_run_id: 'agent-run-3' });
+            // Only the second upload succeeds. Without the failure in the manifest the workflow
+            // would see a complete one-file batch and never report the missing file.
+            mocks.uploadArtifact.mockRejectedValueOnce(new Error('storage unavailable')).mockResolvedValueOnce({});
+            mockStreamState({
+                messages: [],
+                isCompleted: false,
+                initialHistoryStatus: 'empty',
+                agentRunStatus: 'RUNNING',
+            });
+
+            const { container } = renderWithProviders(
+                <ModernAgentConversation startWorkflow={startWorkflow} hideHeader initialMessage="" />,
+            );
+
+            const fileInput = container.querySelector('input[type="file"]') as HTMLInputElement;
+            fireEvent.change(fileInput, {
+                target: {
+                    files: [
+                        new File(['a'], 'broken.pdf', { type: 'application/pdf' }),
+                        new File(['b'], 'good.pdf', { type: 'application/pdf' }),
+                    ],
+                },
+            });
+            fireEvent.change(screen.getByRole('textbox'), { target: { value: 'Look at these files' } });
+            fireEvent.click(screen.getByRole('button', { name: 'Start Agent' }));
+
+            await waitFor(() => {
+                expect(mocks.sendSignal).toHaveBeenCalledWith(
+                    'agent-run-3',
+                    'FileBatchClosed',
+                    expect.objectContaining({
+                        file_ids: [expect.stringMatching(/^file-/)],
+                        failed_uploads: [{ name: 'broken.pdf', error: 'storage unavailable' }],
+                    }),
+                );
+            });
+        });
+
+        it('retries a failed manifest and reports the failure instead of a successful start', async () => {
+            const startWorkflow = vi.fn().mockResolvedValue({ agent_run_id: 'agent-run-4' });
+            const toast = vi.fn();
+            mocks.sendSignal.mockImplementation((_id: string, signalName: string) =>
+                signalName === 'FileBatchClosed' ? Promise.reject(new Error('network down')) : Promise.resolve({}),
+            );
+            mockStreamState({
+                messages: [],
+                isCompleted: false,
+                initialHistoryStatus: 'empty',
+                agentRunStatus: 'RUNNING',
+            });
+
+            const { container } = renderWithProviders(
+                <ToastContext.Provider value={toast}>
+                    <ModernAgentConversation startWorkflow={startWorkflow} hideHeader initialMessage="" />
+                </ToastContext.Provider>,
+            );
+
+            const fileInput = container.querySelector('input[type="file"]') as HTMLInputElement;
+            fireEvent.change(fileInput, {
+                target: { files: [new File(['pdf'], 'report.pdf', { type: 'application/pdf' })] },
+            });
+            fireEvent.change(screen.getByRole('textbox'), { target: { value: 'Look at these files' } });
+            fireEvent.click(screen.getByRole('button', { name: 'Start Agent' }));
+
+            // Three attempts: the manifest is the workflow's only notice that the batch is
+            // complete, so losing it strands the agent on a "[Files Ready]" that never arrives.
+            await waitFor(
+                () => {
+                    expect(mocks.sendSignal.mock.calls.filter((call) => call[1] === 'FileBatchClosed')).toHaveLength(3);
+                },
+                { timeout: 5000 },
+            );
+
+            await waitFor(() => {
+                expect(toast).toHaveBeenCalledWith(
+                    expect.objectContaining({
+                        status: 'error',
+                        title: 'Files were not delivered to the agent',
+                    }),
+                );
+            });
+            expect(toast).not.toHaveBeenCalledWith(expect.objectContaining({ title: 'Agent started' }));
+        });
+    });
+
     it('does not restart or send from a terminal run that cannot continue', () => {
         mockStreamState({
             messages: [createMessage(AgentMessageType.COMPLETE, 'done')],

package/src/features/agent/chat/ModernAgentConversation.tsx

@@ -1,3 +1,4 @@
+import type { VertesiaClient } from '@vertesia/client';
 import {
     type ActiveWorkstreamEntry,
     type AgentMessage,
@@ -6,6 +7,7 @@ import {
     type AgentToolApprovalMode,
     type CompletedWorkstreamEntry,
     type ConversationFile,
+    type ConversationFileBatchRef,
     type ConversationFileRef,
     FileProcessingStatus,
     type McpConnectUxConfig,
@@ -119,6 +121,35 @@ export type SendAgentMessageFn = (message: string, inputMetadata?: Record<string
 const EMPTY_STREAMING_MESSAGES = new Map<string, never>();
 const COLLAPSED_STAGED_FILE_COUNT = 3;
 
+const BATCH_CLOSE_RETRY_DELAYS_MS = [400, 1200];
+
+/**
+ * Send the staged-upload manifest, retrying with bounded backoff.
+ *
+ * The manifest is the workflow's only notice that the batch is complete: the start message told
+ * the agent to wait for "[Files Ready]", so dropping it leaves the run waiting for a turn that
+ * never comes. Retries reuse the same `batch_id`, which the workflow treats as idempotent.
+ * Returns false once the retries are exhausted so the caller can report the failure.
+ */
+async function closeStagedFileBatch(
+    client: VertesiaClient,
+    agentId: string,
+    batch: ConversationFileBatchRef,
+): Promise<boolean> {
+    for (let attempt = 0; ; attempt++) {
+        try {
+            await client.agents.sendSignal(agentId, 'FileBatchClosed', batch);
+            return true;
+        } catch (err) {
+            if (attempt >= BATCH_CLOSE_RETRY_DELAYS_MS.length) {
+                console.error('Failed to close staged file batch:', err);
+                return false;
+            }
+            await new Promise((resolve) => setTimeout(resolve, BATCH_CLOSE_RETRY_DELAYS_MS[attempt]));
+        }
+    }
+}
+
 function getTimestampMs(timestamp: number | string | undefined): number {
     if (typeof timestamp === 'number') return timestamp;
     if (!timestamp) return Date.now();
@@ -592,6 +623,12 @@ export interface ModernAgentConversationProps {
     onShowDetails?: () => void;
     /** Whether workflow control actions such as cancel should be shown. */
     allowWorkflowControl?: boolean;
+    /**
+     * Workstream selected on mount instead of "all" — use it to open the conversation on one
+     * sub-agent (a process agent node's workstream is its node id). Initial value only; the user's
+     * later tab choices win.
+     */
+    initialWorkstream?: string;
 
     // File upload props - passed through to MessageInput
     /** Called when files are dropped/pasted/selected */
@@ -1014,56 +1051,85 @@ function StartWorkflowView({
 
             const agentId = newRun.agent_run_id;
 
-            // Upload staged files to the new run's artifact space and signal agent
-            const uploadedFiles: string[] = [];
+            // Upload the staged files inline, NOT via the conversation view: consumers like
+            // StudioAssistantPanel feed the new agentRunId straight back as a prop, which
+            // switches ModernAgentConversation to its agentRunId branch and unmounts this
+            // view — any state handoff dies with it. Inline client calls survive regardless
+            // of what renders next. The closing FileBatchClosed manifest names the batch's
+            // exact membership, so the workflow delivers the "[Files Ready]" turn itself
+            // once — and only once — every listed file has settled, even when a small file
+            // finishes processing while a larger one is still uploading. Once the manifest
+            // lands, delivery no longer depends on this client: extraction can outlast a
+            // reload. The upload loop below still does — a tab closed mid-loop never closes
+            // the batch, which is why the send is retried and its failure surfaced.
+            let stagedBatchDelivered = true;
             if (canStageFiles && stagedFiles.length > 0) {
+                const batchId = `batch-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+                const uploadedFileIds: string[] = [];
+                const failedUploads: { name: string; error?: string }[] = [];
                 for (const file of stagedFiles) {
                     try {
                         const artifactPath = `files/${file.name}`;
                         await client.agents.uploadArtifact(agentId, artifactPath, file);
-
-                        // Signal agent that file was uploaded
+                        const fileId = `file-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
                         await client.agents.sendSignal(agentId, 'FileUploaded', {
-                            id: `file-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
+                            id: fileId,
                             name: file.name,
                             content_type: file.type || 'application/octet-stream',
                             reference: `artifact:${artifactPath}`,
                             artifact_path: artifactPath,
                         } as ConversationFileRef);
-                        uploadedFiles.push(file.name);
+                        uploadedFileIds.push(fileId);
                     } catch (uploadErr) {
                         console.error(`Failed to upload staged file ${file.name}:`, uploadErr);
-                        // Continue with other files
+                        // Carried in the manifest: a 1-of-2 batch would otherwise look
+                        // complete to the workflow and the agent would never hear about it.
+                        failedUploads.push({
+                            name: file.name,
+                            error: uploadErr instanceof Error ? uploadErr.message : String(uploadErr),
+                        });
                     }
                 }
-
-                // Send a follow-up message to notify the agent that all files are ready
-                if (uploadedFiles.length > 0) {
-                    try {
-                        await client.agents.sendSignal(agentId, 'UserInput', {
-                            message: `[Files Ready] All ${uploadedFiles.length} file(s) have been uploaded and are now available: ${uploadedFiles.join(', ')}. You can now process them.`,
-                            metadata: {
-                                type: 'files_ready',
-                                files: uploadedFiles,
-                            },
-                        } as UserInputSignal);
-                    } catch (signalErr) {
-                        console.error('Failed to send files ready signal:', signalErr);
-                    }
+                // Close the batch even when every upload failed — the manifest is what lets
+                // the workflow report the outcome instead of leaving the agent parked.
+                stagedBatchDelivered = await closeStagedFileBatch(client, agentId, {
+                    batch_id: batchId,
+                    file_ids: uploadedFileIds,
+                    failed_uploads: failedUploads.length > 0 ? failedUploads : undefined,
+                });
+                if (stagedBatchDelivered) {
+                    setStagedFiles([]);
+                }
+                if (failedUploads.length > 0) {
+                    toast({
+                        title: t('agent.stagedFilesUploadFailed'),
+                        status: 'warning',
+                        duration: 6000,
+                        description: failedUploads.map((f) => f.name).join(', '),
+                    });
                 }
-
-                setStagedFiles([]);
             }
 
             // Clear attachments after successful start
             onAttachmentsSent?.();
             setStartedAgentRunId(agentId);
             setInputValue('');
-            toast({
-                title: t('agent.agentStarted'),
-                status: 'success',
-                duration: 3000,
-            });
+            if (stagedBatchDelivered) {
+                toast({
+                    title: t('agent.agentStarted'),
+                    status: 'success',
+                    duration: 3000,
+                });
+            } else {
+                // The run exists, but the agent was told to wait for files it will never be
+                // told about — reporting success here would hide that.
+                toast({
+                    title: t('agent.stagedFilesNotDelivered'),
+                    status: 'error',
+                    duration: 8000,
+                    description: t('agent.stagedFilesNotDeliveredDescription'),
+                });
+            }
         } catch (err: unknown) {
             setPendingStartMessage(null);
             setPendingStartTimestamp(null);
@@ -1300,8 +1366,11 @@ function StartWorkflowView({
                             disabled={isSending}
                             rows={2}
                             className={cn(
-                                'min-h-[72px] resize-none overflow-hidden border-0 bg-transparent px-0 py-0 text-sm leading-6 shadow-none focus-visible:ring-0',
-                                isExpandedStartComposer && 'min-h-0 flex-1',
+                                'min-h-[72px] resize-none border-0 bg-transparent px-0 py-0 text-sm leading-6 shadow-none focus-visible:ring-0',
+                                // The expanded composer is a fixed-height flex box (adjustTextareaHeight
+                                // pins it to 100%), so it has to scroll its own overflow. The auto-growing
+                                // variant hides overflow because it resizes to fit instead.
+                                isExpandedStartComposer ? 'min-h-0 flex-1 overflow-y-auto' : 'overflow-hidden',
                                 inputClassName,
                             )}
                             style={
@@ -1453,6 +1522,7 @@ function ModernAgentConversationInner({
     enablePlayback,
     showPlaybackToggle = true,
     messageFilter,
+    initialWorkstream,
 }: ModernAgentConversationProps & { agentRunId: string }) {
     const { t } = useUITranslation();
     const { client } = useUserSession();
@@ -1531,7 +1601,17 @@ function ModernAgentConversationInner({
     );
     const [isStopping, setIsStopping] = useState(false);
     const [isDragOver, setIsDragOver] = useState(false);
-    const [activeWorkstream, setActiveWorkstream] = useState('all');
+    const [activeWorkstream, setActiveWorkstream] = useState(initialWorkstream || 'all');
+    // The route can move to another workstream while this component stays mounted — e.g. between
+    // two agent nodes of the same process run, which differ only by a path param — so follow the
+    // prop whenever it actually changes. A manual tab click still wins until it changes again.
+    const requestedWorkstreamRef = useRef(initialWorkstream);
+    useEffect(() => {
+        if (initialWorkstream && initialWorkstream !== requestedWorkstreamRef.current) {
+            requestedWorkstreamRef.current = initialWorkstream;
+            setActiveWorkstream(initialWorkstream);
+        }
+    }, [initialWorkstream]);
     const [playbackCursor, setPlaybackCursor] = useState<AgentChatPlaybackCursor>('live');
     const [isPlaybackToggleEnabled, setIsPlaybackToggleEnabled] = useState(false);
     const [playbackScrollRequestId, setPlaybackScrollRequestId] = useState(0);

package/src/features/agent/chat/ModernAgentOutput/ActiveWorkstreamsSummary.tsx

@@ -1,6 +1,6 @@
 import { Button, cn } from '@vertesia/ui/core';
 import { useUITranslation } from '@vertesia/ui/i18n';
-import { Bot, ChevronDown, ChevronRight } from 'lucide-react';
+import { Bot, ChevronDown, ChevronRight, ChevronUp } from 'lucide-react';
 import { useEffect, useId, useMemo, useState } from 'react';
 import {
     formatWorkstreamName,
@@ -24,6 +24,7 @@ export function ActiveWorkstreamsSummary({
 }: ActiveWorkstreamsSummaryProps) {
     const { t } = useUITranslation();
     const [isExpanded, setIsExpanded] = useState(false);
+    const [isCollapsed, setIsCollapsed] = useState(false);
     const listId = useId();
     const runningWorkstreams = useMemo(
         () => activeWorkstreams.filter((ws) => ws.status === 'running' || ws.status === 'canceling'),
@@ -49,79 +50,97 @@ export function ActiveWorkstreamsSummary({
                 className="flex flex-col gap-1.5 rounded-2xl border border-border/70 bg-background/95 p-2 text-xs text-muted shadow-lg shadow-black/5"
                 aria-live="polite"
             >
-                <div className="flex min-w-0 items-center gap-2 px-1 font-medium">
-                    <Bot className="size-3.5 shrink-0 text-muted" aria-hidden="true" />
-                    <span className="truncate">
-                        {t('agent.activeWorkstreams', { count: runningWorkstreams.length })}
-                    </span>
+                <div className="flex items-center justify-between gap-2">
+                    <div className="flex min-w-0 items-center gap-2 px-1 font-medium">
+                        <Bot className="size-3.5 shrink-0 text-muted" aria-hidden="true" />
+                        <span className="truncate">
+                            {t('agent.activeWorkstreams', { count: runningWorkstreams.length })}
+                        </span>
+                    </div>
+                    <Button
+                        variant="ghost"
+                        size="icon"
+                        onClick={() => setIsCollapsed(!isCollapsed)}
+                        title={isCollapsed ? t('agent.showActiveWorkstreams') : t('agent.hideActiveWorkstreams')}
+                    >
+                        {isCollapsed ? <ChevronUp className="size-4" /> : <ChevronDown className="size-4" />}
+                        {isCollapsed ? t('agent.showActiveWorkstreams') : t('agent.hideActiveWorkstreams')}
+                    </Button>
                 </div>
-                <div id={listId} className="flex flex-col gap-0.5">
-                    {visibleRunningWorkstreams.map((workstream) => {
-                        const workstreamName = getWorkstreamDisplayName(
-                            workstream.workstream_id,
-                            workstream.interaction,
-                        );
-                        const content = (
-                            <>
-                                <span
-                                    className={cn(
-                                        'size-1.5 shrink-0 rounded-full',
-                                        getWorkstreamStatusClass(workstream.status),
-                                    )}
-                                    aria-hidden="true"
-                                />
-                                <span className="truncate font-medium">{workstreamName}</span>
-                                {workstream.phase && (
-                                    <span className="truncate text-xs text-muted/75">
-                                        {formatWorkstreamName(workstream.phase)}
-                                    </span>
-                                )}
-                            </>
-                        );
+                {isCollapsed ? null : (
+                    <>
+                        <div id={listId} className="flex flex-col gap-0.5">
+                            {visibleRunningWorkstreams.map((workstream) => {
+                                const workstreamName = getWorkstreamDisplayName(
+                                    workstream.workstream_id,
+                                    workstream.interaction,
+                                );
+                                const content = (
+                                    <>
+                                        <span
+                                            className={cn(
+                                                'size-1.5 shrink-0 rounded-full',
+                                                getWorkstreamStatusClass(workstream.status),
+                                            )}
+                                            aria-hidden="true"
+                                        />
+                                        <span className="truncate font-medium">{workstreamName}</span>
+                                        {workstream.phase && (
+                                            <span className="truncate text-xs text-muted/75">
+                                                {formatWorkstreamName(workstream.phase)}
+                                            </span>
+                                        )}
+                                    </>
+                                );
 
-                        return onSelectWorkstream ? (
+                                return onSelectWorkstream ? (
+                                    <Button
+                                        key={workstream.launch_id || workstream.workstream_id}
+                                        type="button"
+                                        variant="ghost"
+                                        className="h-auto min-w-0 justify-start gap-2 rounded-lg px-1 py-1 text-sm text-foreground/80"
+                                        title={workstreamName}
+                                        onClick={() => {
+                                            setIsExpanded(false);
+                                            onSelectWorkstream(workstream.workstream_id);
+                                        }}
+                                    >
+                                        {content}
+                                        <ChevronRight
+                                            className="ms-auto size-3.5 shrink-0 rtl:rotate-180"
+                                            aria-hidden="true"
+                                        />
+                                    </Button>
+                                ) : (
+                                    <div
+                                        key={workstream.launch_id || workstream.workstream_id}
+                                        className="flex min-w-0 items-center gap-2 rounded-lg px-1 py-1 text-sm text-foreground/80"
+                                        title={workstreamName}
+                                    >
+                                        {content}
+                                    </div>
+                                );
+                            })}
+                        </div>
+                        {canExpand && (
                             <Button
-                                key={workstream.launch_id || workstream.workstream_id}
                                 type="button"
                                 variant="ghost"
-                                className="h-auto min-w-0 justify-start gap-2 rounded-lg px-1 py-1 text-sm text-foreground/80"
-                                title={workstreamName}
-                                onClick={() => {
-                                    setIsExpanded(false);
-                                    onSelectWorkstream(workstream.workstream_id);
-                                }}
+                                size="sm"
+                                className="h-8 w-fit shrink-0 gap-1 rounded-xl px-2.5 text-xs text-muted"
+                                aria-expanded={isExpanded}
+                                aria-controls={listId}
+                                onClick={() => setIsExpanded((expanded) => !expanded)}
                             >
-                                {content}
-                                <ChevronRight className="ms-auto size-3.5 shrink-0 rtl:rotate-180" aria-hidden="true" />
+                                {!isExpanded && <span>+{hiddenRunningWorkstreamCount}</span>}
+                                {isExpanded ? t('agent.showLess') : t('agent.showMore')}
+                                <ChevronDown
+                                    className={cn('size-3.5 transition-transform', isExpanded && 'rotate-180')}
+                                    aria-hidden="true"
+                                />
                             </Button>
-                        ) : (
-                            <div
-                                key={workstream.launch_id || workstream.workstream_id}
-                                className="flex min-w-0 items-center gap-2 rounded-lg px-1 py-1 text-sm text-foreground/80"
-                                title={workstreamName}
-                            >
-                                {content}
-                            </div>
-                        );
-                    })}
-                </div>
-                {canExpand && (
-                    <Button
-                        type="button"
-                        variant="ghost"
-                        size="sm"
-                        className="h-8 w-fit shrink-0 gap-1 rounded-xl px-2.5 text-xs text-muted"
-                        aria-expanded={isExpanded}
-                        aria-controls={listId}
-                        onClick={() => setIsExpanded((expanded) => !expanded)}
-                    >
-                        {!isExpanded && <span>+{hiddenRunningWorkstreamCount}</span>}
-                        {isExpanded ? t('agent.showLess') : t('agent.showMore')}
-                        <ChevronDown
-                            className={cn('size-3.5 transition-transform', isExpanded && 'rotate-180')}
-                            aria-hidden="true"
-                        />
-                    </Button>
+                        )}
+                    </>
                 )}
             </output>
         </div>