@vertesia/ui 1.5.0-dev.20260725.083715Z → 1.5.0-dev.20260806.125520Z

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

@@ -66,6 +66,7 @@ interface MessageInputProps {
     isCompactingContext?: boolean;
     activeTaskCount?: number;
     activeWorkstreams?: WorkstreamInfo[];
+    onSelectWorkstream?: (workstreamId: string) => void;
     placeholder?: string;
 
     // File upload props
@@ -133,6 +134,7 @@ export default function MessageInput({
     isCompactingContext = false,
     activeTaskCount = 0,
     activeWorkstreams = [],
+    onSelectWorkstream,
     placeholder,
     // File upload props
     onFilesSelected,
@@ -474,7 +476,7 @@ export default function MessageInput({
                 />
             )}
 
-            <ActiveWorkstreamsSummary activeWorkstreams={activeWorkstreams} />
+            <ActiveWorkstreamsSummary activeWorkstreams={activeWorkstreams} onSelectWorkstream={onSelectWorkstream} />
 
             {/* Input row */}
             <div className="mx-auto flex max-w-3xl flex-col gap-2 rounded-2xl border border-border/70 bg-mixer-muted/15 p-2.5 shadow-lg shadow-black/5">

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

@@ -37,7 +37,7 @@ import { createAgentMarkdownAnchor } from './AgentMarkdownAnchor';
 import { AttachmentPreviewList, parseUserMessageAttachments } from './AttachmentPreview';
 import { MessageDeliveryStatus } from './MessageDeliveryStatus';
 import { processContentForMarkdown } from './processContentForMarkdown';
-import { getToolApprovalResponseMetadata } from './requestInputMessages';
+import { getToolApprovalResponseMetadata, sendRequestInputResponse } from './requestInputMessages';
 import { getWorkstreamId } from './utils';
 
 /** className overrides for MessageItem — single source of truth for all className overrides. */
@@ -625,13 +625,27 @@ function MessageItemComponent({
                             variant={askUserUx.variant}
                             multiSelect={askUserUx.multiSelect}
                             onSelect={(optionId) =>
-                                onSendMessage?.(optionId, getToolApprovalResponseMetadata(message, optionId))
+                                sendRequestInputResponse(
+                                    onSendMessage,
+                                    message,
+                                    optionId,
+                                    getToolApprovalResponseMetadata(message, optionId),
+                                )
+                            }
+                            onMultiSelect={(optionIds) =>
+                                sendRequestInputResponse(onSendMessage, message, optionIds.join(', '))
                             }
-                            onMultiSelect={(optionIds) => onSendMessage?.(optionIds.join(', '))}
                             allowFreeResponse={!askUserUx.options?.length || !!askUserUx.free_response}
                             placeholder={askUserUx.free_response?.placeholder}
                             submitLabel={askUserUx.free_response?.submit_label}
-                            onSubmit={(value) => onSendMessage?.(value, askUserUx.free_response?.metadata)}
+                            onSubmit={(value) =>
+                                sendRequestInputResponse(
+                                    onSendMessage,
+                                    message,
+                                    value,
+                                    askUserUx.free_response?.metadata,
+                                )
+                            }
                             hideBorder
                             compact
                             answered={requestInputAnswered}

package/src/features/agent/chat/ModernAgentOutput/SummaryConversation.ts

@@ -181,12 +181,21 @@ function isWorkstreamActivityFailureMessage(message: AgentMessage): boolean {
               tool_event?: unknown;
               tool_run_id?: unknown;
               tool_status?: unknown;
+              workstream_id?: unknown;
               workstream_event?: unknown;
           }
         | undefined;
 
     if (details?.event_class !== 'activity') return false;
     if (details.workstream_event) return false;
+    const workstreamId =
+        typeof message.workstream_id === 'string' && message.workstream_id.trim()
+            ? message.workstream_id.trim()
+            : typeof details.workstream_id === 'string'
+              ? details.workstream_id.trim()
+              : '';
+    const normalizedWorkstreamId = workstreamId.toLowerCase();
+    if (!workstreamId || normalizedWorkstreamId === 'main' || normalizedWorkstreamId === 'all') return false;
 
     return !(
         details.tool ||

package/src/features/agent/chat/ModernAgentOutput/requestInputMessages.test.ts

@@ -1,9 +1,16 @@
 import { type AgentMessage, AgentMessageType } from '@vertesia/common';
 import { describe, expect, it } from 'vitest';
 import {
+    clearRequestInputIdAnsweredForSession,
+    getAnsweredRequestInputKeys,
     getAnsweredToolApprovalRequestInputKeys,
+    getPendingRequestInputMessage,
     getRequestInputMessageKey,
+    getRequestInputResponseIdFromMetadata,
+    getRequestInputResponseMetadata,
     getToolApprovalResponseMetadata,
+    isRequestInputAnsweredForSession,
+    markRequestInputIdAnsweredForSession,
 } from './requestInputMessages';
 
 const APPROVAL_KEY = 'create_interaction:name:JDE AR Payment Processing Agent';
@@ -78,3 +85,91 @@ describe('getAnsweredToolApprovalRequestInputKeys', () => {
         expect(answered.size).toBe(0);
     });
 });
+
+describe('request input correlation', () => {
+    it('does not apply session acknowledgement to non-request-input messages with the same id', () => {
+        const agentRunId = 'agent-run-1';
+        const requestId = 'request-1';
+        const request = {
+            ...makeApprovalRequest(),
+            details: { request_id: requestId, ux: { options: [{ id: 'allow_once' }] } },
+        };
+        const unrelatedMessage = {
+            ...makeUserAnswer('Still working'),
+            details: { request_id: requestId },
+        };
+
+        markRequestInputIdAnsweredForSession(agentRunId, requestId);
+
+        expect(isRequestInputAnsweredForSession(agentRunId, request)).toBe(true);
+        expect(isRequestInputAnsweredForSession(agentRunId, unrelatedMessage)).toBe(false);
+
+        clearRequestInputIdAnsweredForSession(agentRunId, requestId);
+    });
+
+    it('correlates a persisted response to the matching request id', () => {
+        const firstRequest = {
+            ...makeApprovalRequest(),
+            details: { request_id: 'request-1', ux: { options: [{ id: 'red', label: 'Red' }] } },
+        };
+        const secondRequest = {
+            ...makeApprovalRequest(),
+            timestamp: 2,
+            details: { request_id: 'request-2', ux: { options: [{ id: 'blue', label: 'Blue' }] } },
+        };
+        const answer = {
+            ...makeUserAnswer('red'),
+            timestamp: 3,
+            details: { request_input_response: { request_id: 'request-1' } },
+        };
+
+        const answered = getAnsweredRequestInputKeys([firstRequest, secondRequest, answer]);
+
+        expect(answered.has(getRequestInputMessageKey(firstRequest))).toBe(true);
+        expect(answered.has(getRequestInputMessageKey(secondRequest))).toBe(false);
+        expect(getPendingRequestInputMessage([firstRequest, secondRequest, answer])).toBe(secondRequest);
+    });
+
+    it('adds the request id without discarding existing response metadata', () => {
+        const request = {
+            ...makeApprovalRequest(),
+            details: { request_id: 'request-1', ux: { options: [{ id: 'red', label: 'Red' }] } },
+        };
+
+        expect(getRequestInputResponseMetadata(request, { source: 'free-response' })).toEqual({
+            source: 'free-response',
+            request_input_response: { request_id: 'request-1' },
+        });
+    });
+
+    it('does not let an earlier response resolve a later prompt that reused its request id', () => {
+        const firstRequest = {
+            ...makeApprovalRequest(),
+            details: { request_id: 'reused-request', ux: { options: [{ id: 'allow_once' }] } },
+        };
+        const firstAnswer = {
+            ...makeUserAnswer('allow_once'),
+            details: { request_input_response: { request_id: 'reused-request' } },
+        };
+        const secondRequest = {
+            ...makeApprovalRequest(),
+            timestamp: 3,
+            details: { request_id: 'reused-request', ux: { options: [{ id: 'allow_once' }] } },
+        };
+
+        const answered = getAnsweredRequestInputKeys([firstRequest, firstAnswer, secondRequest]);
+
+        expect(answered.has(getRequestInputMessageKey(firstRequest))).toBe(true);
+        expect(answered.has(getRequestInputMessageKey(secondRequest))).toBe(false);
+        expect(getPendingRequestInputMessage([firstRequest, firstAnswer, secondRequest])).toBe(secondRequest);
+    });
+
+    it('reads a request id from response metadata', () => {
+        expect(
+            getRequestInputResponseIdFromMetadata({
+                request_input_response: { request_id: 'request-1' },
+            }),
+        ).toBe('request-1');
+        expect(getRequestInputResponseIdFromMetadata({ request_input_response: {} })).toBeUndefined();
+    });
+});

package/src/features/agent/chat/ModernAgentOutput/requestInputMessages.ts

@@ -96,6 +96,65 @@ export function getRequestInputMessageKey(message: AgentMessage): string {
         .join('|');
 }
 
+export function getRequestInputId(message: AgentMessage): string | undefined {
+    const details = message.details as Record<string, unknown> | undefined;
+    const requestId = details?.request_id ?? details?.tool_use_id;
+    return typeof requestId === 'string' && requestId ? requestId : undefined;
+}
+
+export function getRequestInputResolutionKey(message: AgentMessage): string {
+    return getRequestInputId(message) ?? getRequestInputMessageKey(message);
+}
+
+const ANSWERED_REQUEST_INPUT_STORAGE_PREFIX = 'vertesia:answered-request-input:';
+
+function getAnsweredRequestInputStorageKey(agentRunId: string, requestId: string): string {
+    return `${ANSWERED_REQUEST_INPUT_STORAGE_PREFIX}${agentRunId}:${requestId}`;
+}
+
+export function markRequestInputIdAnsweredForSession(agentRunId: string, requestId: string): void {
+    if (typeof window === 'undefined') return;
+
+    try {
+        window.sessionStorage.setItem(getAnsweredRequestInputStorageKey(agentRunId, requestId), '1');
+    } catch {
+        // Session storage can be unavailable in privacy-restricted browser contexts.
+    }
+}
+
+export function clearRequestInputIdAnsweredForSession(agentRunId: string, requestId: string): void {
+    if (typeof window === 'undefined') return;
+
+    try {
+        window.sessionStorage.removeItem(getAnsweredRequestInputStorageKey(agentRunId, requestId));
+    } catch {
+        // Session storage can be unavailable in privacy-restricted browser contexts.
+    }
+}
+
+export function isRequestInputAnsweredForSession(agentRunId: string, message: AgentMessage): boolean {
+    if (message.type !== AgentMessageType.REQUEST_INPUT) return false;
+
+    const requestId = getRequestInputId(message);
+    if (!requestId || typeof window === 'undefined') return false;
+
+    try {
+        return window.sessionStorage.getItem(getAnsweredRequestInputStorageKey(agentRunId, requestId)) === '1';
+    } catch {
+        return false;
+    }
+}
+
+function getRequestInputResponseId(message: AgentMessage): string | undefined {
+    if (message.type !== AgentMessageType.QUESTION) return undefined;
+
+    const details = getRecord(message.details);
+    const metadata = getRecord(details?.metadata);
+    const response = getRecord(details?.request_input_response) ?? getRecord(metadata?.request_input_response);
+    const requestId = response?.request_id;
+    return typeof requestId === 'string' && requestId ? requestId : undefined;
+}
+
 export function getRequestInputAnswerMessageKey(message: AgentMessage): string {
     const details = message.details as Record<string, unknown> | undefined;
     const keyParts = [
@@ -114,10 +173,22 @@ export function getRequestInputAnswerMessageKey(message: AgentMessage): string {
 
 export function getAnsweredRequestInputKeys(messages: AgentMessage[]): Set<string> {
     const answered = new Set<string>();
+    const latestResponseIndexByRequestId = new Map<string, number>();
+    messages.forEach((message, index) => {
+        const requestId = getRequestInputResponseId(message);
+        if (requestId) latestResponseIndexByRequestId.set(requestId, index);
+    });
 
     messages.forEach((message, index) => {
         if (message.type !== AgentMessageType.REQUEST_INPUT) return;
 
+        const requestId = getRequestInputId(message);
+        const correlatedResponseIndex = requestId ? latestResponseIndexByRequestId.get(requestId) : undefined;
+        if (correlatedResponseIndex !== undefined && correlatedResponseIndex > index) {
+            answered.add(getRequestInputMessageKey(message));
+            return;
+        }
+
         const workstreamId = getWorkstreamId(message);
         for (let nextIndex = index + 1; nextIndex < messages.length; nextIndex += 1) {
             const nextMessage = messages[nextIndex];
@@ -125,7 +196,9 @@ export function getAnsweredRequestInputKeys(messages: AgentMessage[]): Set<strin
 
             if (nextMessage.type === AgentMessageType.REQUEST_INPUT) break;
             if (nextMessage.type === AgentMessageType.QUESTION) {
-                answered.add(getRequestInputMessageKey(message));
+                if (!getRequestInputResponseId(nextMessage)) {
+                    answered.add(getRequestInputMessageKey(message));
+                }
                 break;
             }
         }
@@ -134,6 +207,41 @@ export function getAnsweredRequestInputKeys(messages: AgentMessage[]): Set<strin
     return answered;
 }
 
+export function getRequestInputResponseMetadata(
+    message: AgentMessage,
+    metadata?: Record<string, unknown>,
+): Record<string, unknown> | undefined {
+    const requestId = getRequestInputId(message);
+    if (!requestId) return metadata;
+
+    return {
+        ...metadata,
+        request_input_response: { request_id: requestId },
+    };
+}
+
+export function sendRequestInputResponse(
+    onSendMessage: ((message: string, metadata?: Record<string, unknown>) => void) | undefined,
+    requestMessage: AgentMessage,
+    response: string,
+    metadata?: Record<string, unknown>,
+): void {
+    if (!onSendMessage) return;
+
+    const responseMetadata = getRequestInputResponseMetadata(requestMessage, metadata);
+    if (responseMetadata) {
+        onSendMessage(response, responseMetadata);
+    } else {
+        onSendMessage(response);
+    }
+}
+
+export function getRequestInputResponseIdFromMetadata(metadata?: Record<string, unknown>): string | undefined {
+    const response = getRecord(metadata?.request_input_response);
+    const requestId = response?.request_id;
+    return typeof requestId === 'string' && requestId ? requestId : undefined;
+}
+
 export function getResolvedToolApprovalKeys(messages: AgentMessage[]): Set<string> {
     const resolved = new Set<string>();
 
@@ -300,6 +408,7 @@ export function isRequestInputAnswered(message: AgentMessage, answeredRequestInp
 export function getPendingRequestInputMessage(
     messages: AgentMessage[],
     workstreamId = 'main',
+    locallyAnsweredRequestInputKeys?: ReadonlySet<string>,
 ): RequestInputMessageWithUx | undefined {
     const answeredRequestInputKeys = getAnsweredRequestInputKeys(messages);
     const resolvedToolApprovalKeys = getResolvedToolApprovalKeys(messages);
@@ -308,6 +417,7 @@ export function getPendingRequestInputMessage(
         const message = messages[index];
         if (!hasRequestInputUx(message)) continue;
         if (getWorkstreamId(message) !== workstreamId) continue;
+        if (locallyAnsweredRequestInputKeys?.has(getRequestInputResolutionKey(message))) continue;
         if (isRequestInputAnswered(message, answeredRequestInputKeys)) continue;
         if (isRequestInputResolvedByToolApprovalEvent(message, resolvedToolApprovalKeys)) continue;
         return message;

package/src/features/agent/chat/ModernAgentOutput/utils.test.ts

@@ -576,6 +576,27 @@ describe('ModernAgentOutput summary conversation items', () => {
         ]);
     });
 
+    it('keeps a main-workstream activity error visible as a primary message', () => {
+        const question = makeMessage({
+            timestamp: 1000,
+            type: AgentMessageType.QUESTION,
+            message: 'do the thing',
+        });
+        const terminationError = makeMessage({
+            timestamp: 1100,
+            type: AgentMessageType.ERROR,
+            message: 'Stopped: the agent called create_document with the same input 4 times in a row.',
+            details: { event_class: 'activity' },
+        });
+
+        const items = buildSummaryConversationItems([question, terminationError], true);
+
+        expect(items).toEqual([
+            { type: 'message', message: question },
+            { type: 'message', message: terminationError },
+        ]);
+    });
+
     it('hides transient thinking once the work segment completes', () => {
         const tool = makeMessage({
             timestamp: 1000,

package/src/features/agent/chat/hooks/useAgentStream.test.tsx

@@ -312,6 +312,68 @@ describe('useAgentStream', () => {
         expect(onMessage).toHaveBeenCalledTimes(1);
     });
 
+    it('does not apply replayed file_processing snapshots to server file updates', async () => {
+        let deliver: ((message: AgentMessage) => void) | undefined;
+        const fileSnapshot = (timestamp: number, id: string): AgentMessage => ({
+            timestamp,
+            workflow_run_id: 'run-1',
+            type: AgentMessageType.SYSTEM,
+            message: '',
+            workstream_id: 'main',
+            details: {
+                system_type: 'file_processing',
+                batch_id: 'batch-1',
+                files: [
+                    {
+                        id,
+                        name: `${id}.pdf`,
+                        content_type: 'application/pdf',
+                        size: 1,
+                        status: FileProcessingStatus.READY,
+                        artifact_path: `files/${id}.pdf`,
+                        reference: `artifact:files/${id}.pdf`,
+                        started_at: timestamp,
+                    },
+                ],
+                pending_count: 0,
+                ready_count: 1,
+                error_count: 0,
+            },
+        });
+        const historical = fileSnapshot(1_000, 'old-upload');
+        const streamMessages = vi.fn<
+            (
+                id: string,
+                onMessage?: (message: AgentMessage, exitFn?: (payload: unknown) => void) => void,
+                since?: number,
+                signal?: AbortSignal,
+                options?: AgentRunStreamMessagesOptions,
+            ) => Promise<unknown>
+        >(async (_id, onMessage, _since, _signal, options) => {
+            deliver = onMessage;
+            options?.onHistoryLoaded?.([historical]);
+            // Completed runs replay archived file_processing snapshots through the
+            // live callback; applying them would rehydrate every historical upload
+            // as a staged composer chip on reopen.
+            onMessage?.(historical);
+            return null;
+        });
+        const client = createClient(streamMessages);
+        const { result } = renderHook(() => useAgentStream(client, 'agent-run-1', vi.fn()));
+
+        await waitFor(() => expect(deliver).toBeDefined());
+        // History hydrates the latest archived inventory once so an unconsumed staged file
+        // survives a reload; the live replay of that same snapshot is ignored, leaving the
+        // hydrated entry untouched. Already-delivered files are dropped downstream by
+        // useFileProcessing (consumed_at + delivered artifact refs), not by refusing to hydrate.
+        expect(result.current.serverFileUpdates.size).toBe(1);
+        expect(result.current.serverFileUpdates.has('old-upload')).toBe(true);
+
+        act(() => deliver?.(fileSnapshot(1_100, 'new-upload')));
+        expect(result.current.serverFileUpdates.size).toBe(1);
+        expect(result.current.serverFileUpdates.has('new-upload')).toBe(true);
+    });
+
     it('marks initial history as errored when the history fetch fails', async () => {
         const streamMessages = vi.fn<
             (
@@ -786,4 +848,114 @@ describe('useAgentStream', () => {
 
         expect(result.current.serverFileUpdates.has('file-1')).toBe(false);
     });
+
+    it('hydrates the latest historical file snapshot once and ignores its live replay', async () => {
+        let deliver: ((message: AgentMessage) => void) | undefined;
+        const fileSnapshot = (timestamp: number, id: string): AgentMessage => ({
+            timestamp,
+            workflow_run_id: 'run-1',
+            type: AgentMessageType.SYSTEM,
+            message: '',
+            workstream_id: 'main',
+            details: {
+                system_type: 'file_processing',
+                batch_id: 'batch-1',
+                files: [
+                    {
+                        id,
+                        name: `${id}.pdf`,
+                        content_type: 'application/pdf',
+                        size: 1,
+                        status: FileProcessingStatus.READY,
+                        artifact_path: `files/${id}.pdf`,
+                        reference: `artifact:files/${id}.pdf`,
+                        started_at: timestamp,
+                    },
+                ],
+                pending_count: 0,
+                ready_count: 1,
+                error_count: 0,
+            },
+        });
+        const olderHistorical = fileSnapshot(1_000, 'older-upload');
+        const latestHistorical = fileSnapshot(1_100, 'staged-upload');
+        const streamMessages = vi.fn<
+            (
+                id: string,
+                onMessage?: (message: AgentMessage, exitFn?: (payload: unknown) => void) => void,
+                since?: number,
+                signal?: AbortSignal,
+                options?: AgentRunStreamMessagesOptions,
+            ) => Promise<unknown>
+        >(async (_id, onMessage, _since, _signal, options) => {
+            deliver = onMessage;
+            options?.onHistoryLoaded?.([olderHistorical, latestHistorical]);
+            // Completed runs replay archived file_processing snapshots through the
+            // live callback. Replaying the older snapshot must not replace the latest
+            // inventory selected from history.
+            onMessage?.(olderHistorical);
+            return null;
+        });
+        const client = createClient(streamMessages);
+        const { result } = renderHook(() => useAgentStream(client, 'agent-run-1'));
+
+        await waitFor(() => expect(deliver).toBeDefined());
+        expect(result.current.serverFileUpdates.size).toBe(1);
+        expect(result.current.serverFileUpdates.has('staged-upload')).toBe(true);
+
+        act(() => deliver?.(fileSnapshot(1_200, 'new-upload')));
+        expect(result.current.serverFileUpdates.size).toBe(1);
+        expect(result.current.serverFileUpdates.has('new-upload')).toBe(true);
+    });
+
+    it('selects the newest historical file snapshot even when history arrives out of order', async () => {
+        let deliver: ((message: AgentMessage) => void) | undefined;
+        const fileSnapshot = (timestamp: number, id: string): AgentMessage => ({
+            timestamp,
+            workflow_run_id: 'run-1',
+            type: AgentMessageType.SYSTEM,
+            message: '',
+            workstream_id: 'main',
+            details: {
+                system_type: 'file_processing',
+                batch_id: 'batch-1',
+                files: [
+                    {
+                        id,
+                        name: `${id}.pdf`,
+                        content_type: 'application/pdf',
+                        size: 1,
+                        status: FileProcessingStatus.READY,
+                        artifact_path: `files/${id}.pdf`,
+                        reference: `artifact:files/${id}.pdf`,
+                        started_at: timestamp,
+                    },
+                ],
+                pending_count: 0,
+                ready_count: 1,
+                error_count: 0,
+            },
+        });
+        const streamMessages = vi.fn<
+            (
+                id: string,
+                onMessage?: (message: AgentMessage, exitFn?: (payload: unknown) => void) => void,
+                since?: number,
+                signal?: AbortSignal,
+                options?: AgentRunStreamMessagesOptions,
+            ) => Promise<unknown>
+        >(async (_id, onMessage, _since, _signal, options) => {
+            deliver = onMessage;
+            // retrieveMessages returns GET /updates unsorted, so the newest snapshot is not
+            // necessarily last. Selection must be by timestamp, not arrival order.
+            options?.onHistoryLoaded?.([fileSnapshot(1_100, 'staged-upload'), fileSnapshot(1_000, 'older-upload')]);
+            return null;
+        });
+        const client = createClient(streamMessages);
+        const { result } = renderHook(() => useAgentStream(client, 'agent-run-1'));
+
+        await waitFor(() => expect(deliver).toBeDefined());
+        expect(result.current.serverFileUpdates.size).toBe(1);
+        expect(result.current.serverFileUpdates.has('staged-upload')).toBe(true);
+    });
 });

package/src/features/agent/chat/hooks/useAgentStream.ts

@@ -357,9 +357,12 @@ export function useAgentStream(
                 (message) => {
                     if (abortController.signal.aborted) return;
                     // Completed and idle runs replay their archived history through the live
-                    // stream. Only forward genuinely new deliveries so onMessage consumers
+                    // stream. Track replay status once, before the cursor advances below —
+                    // every replay-sensitive consumer in this callback must use it.
+                    const isReplay = Boolean(message.timestamp && message.timestamp <= lastDeliveredTsRef.current);
+                    // Only forward genuinely new deliveries so onMessage consumers
                     // never treat replayed events as fresh ones.
-                    if (!message.timestamp || message.timestamp > lastDeliveredTsRef.current) {
+                    if (!isReplay) {
                         onMessageRef.current?.(message);
                     }
 
@@ -426,7 +429,13 @@ export function useAgentStream(
                     if (message.type === AgentMessageType.SYSTEM) {
                         const details = message.details as FileProcessingDetails | undefined;
                         if (details?.system_type === 'file_processing' && details.files) {
-                            setServerFileUpdates(new Map(details.files.map((file) => [file.id, file])));
+                            // Replayed snapshots list every file ever uploaded to the run as
+                            // READY; applying them on reconnect would rehydrate historical
+                            // uploads as staged composer chips. Only genuinely new updates
+                            // may touch the file state.
+                            if (!isReplay) {
+                                setServerFileUpdates(new Map(details.files.map((file) => [file.id, file])));
+                            }
                             return;
                         }
                         // Other SYSTEM messages fall through to normal handling
@@ -467,13 +476,39 @@ export function useAgentStream(
                     onHistoryLoaded: (historical) => {
                         if (abortController.signal.aborted) return;
                         const timelineMessages = historical.filter(shouldStoreTimelineMessage);
+                        let latestFileSnapshot: FileProcessingDetails | undefined;
+                        let latestFileSnapshotTs = Number.NEGATIVE_INFINITY;
                         // Advance the watermark synchronously before React processes the
                         // history state update. Some completed streams replay history via
                         // the live callback immediately after onHistoryLoaded returns.
+                        // Must cover every historical message, not just the timeline subset:
+                        // file_processing snapshots are excluded from timelineMessages, so
+                        // scanning only that subset would leave the cursor behind them and
+                        // the replay guard would never fire for a file-only history.
                         for (const message of historical) {
                             if (message.timestamp && message.timestamp > lastDeliveredTsRef.current) {
                                 lastDeliveredTsRef.current = message.timestamp;
                             }
+                            if (message.type === AgentMessageType.SYSTEM) {
+                                const details = message.details as FileProcessingDetails | undefined;
+                                if (details?.system_type === 'file_processing' && details.files) {
+                                    // GET /updates is returned unsorted (the client only ever
+                                    // takes a Math.max over timestamps), so select the newest
+                                    // snapshot by timestamp instead of trusting arrival order.
+                                    // >= keeps last-wins for ties and for untimestamped messages.
+                                    const timestamp = message.timestamp ?? Number.NEGATIVE_INFINITY;
+                                    if (!latestFileSnapshot || timestamp >= latestFileSnapshotTs) {
+                                        latestFileSnapshot = details;
+                                        latestFileSnapshotTs = timestamp;
+                                    }
+                                }
+                            }
+                        }
+                        // Hydrate the latest archived inventory once so an unconsumed staged file
+                        // remains visible after reload. Subsequent live-callback replay is ignored
+                        // by isReplay above, while useFileProcessing filters consumed/delivered files.
+                        if (latestFileSnapshot) {
+                            setServerFileUpdates(new Map(latestFileSnapshot.files.map((file) => [file.id, file])));
                         }
                         debugAgentChat('history loaded', {
                             agentRunId,