diff --git a/application/single_app/config.py b/application/single_app/config.py
index 143f847b8..ef6a7d47c 100644
--- a/application/single_app/config.py
+++ b/application/single_app/config.py
@@ -101,7 +101,7 @@
 EXECUTOR_TYPE = 'thread'
 EXECUTOR_MAX_WORKERS = 30
 SESSION_TYPE = 'filesystem'
-VERSION = "0.261.301"
+VERSION = "0.261.302"
 IS_DEVELOPMENT = is_development_env_enabled()
 
 # Opt-out for deployments where App Service Easy Auth is active but the platform
diff --git a/application/single_app/functions_collaboration_generated_documents.py b/application/single_app/functions_collaboration_generated_documents.py
index 2c397ebec..46a9c099a 100644
--- a/application/single_app/functions_collaboration_generated_documents.py
+++ b/application/single_app/functions_collaboration_generated_documents.py
@@ -1,11 +1,12 @@
 # functions_collaboration_generated_documents.py
-"""Documents that agents generated in a shared conversation, and who may download them.
+"""Documents that agents generated in a conversation, and who may download them.
 
 An agent creates a document with the SimpleChat action's upload functions. Each stores the file
 in the requester's personal workspace or in a group workspace and returns its id, which stays on
-the message in the agent citation. That is what lets a shared conversation list what was produced
-in it. Listing reveals only file names; downloading follows the workspace's own download rules,
-whichever group the reader currently has active.
+the message in the agent citation. That is what lets a conversation list what was produced in it,
+whether it is a shared conversation or a personal one. Listing reveals only file names;
+downloading follows the workspace's own download rules, whichever group the reader currently has
+active.
 """
 
 import json
diff --git a/application/single_app/route_backend_conversations.py b/application/single_app/route_backend_conversations.py
index 8f13518b6..b1682541c 100644
--- a/application/single_app/route_backend_conversations.py
+++ b/application/single_app/route_backend_conversations.py
@@ -61,7 +61,13 @@
 from flask import Response, current_app, request, stream_with_context
 from werkzeug.utils import secure_filename
 from functions_debug import debug_print
+from functions_collaboration_generated_documents import (
+    authorize_generated_document_download,
+    can_download_generated_document,
+    collect_generated_documents,
+)
 from functions_documents import (
+    build_document_download_response,
     delete_chat_upload_workspace_documents_for_conversation,
     serialize_chat_upload_workspace_documents_for_conversation,
 )
@@ -969,6 +975,54 @@ def hydrate_m365_pending_action_cards(messages, viewer_user_id, conversation_id)
     )
 
 
+def _list_personal_conversation_generated_documents(conversation_item):
+    """Return the documents SimpleChat upload actions created in a personal conversation.
+
+    ``conversation_item`` must already be authorized with ``_authorize_personal_conversation_read``.
+    Only messages the thread shows are read, filtered the way ``/api/get_messages`` filters them:
+    deleted messages, the assistant artifact store, hidden generated chat files and replaced
+    thread attempts are left out. A citation stored in compact form is rebuilt from its artifact
+    record first, because the created document's id is in the full tool result.
+    """
+    conversation_id = conversation_item['id']
+    raw_messages = list(cosmos_messages_container.query_items(
+        query='SELECT * FROM c WHERE c.conversation_id = @conversation_id',
+        parameters=[{'name': '@conversation_id', 'value': conversation_id}],
+        partition_key=conversation_id,
+    ))
+    raw_messages.sort(key=lambda item: (
+        str(item.get('timestamp') or ''),
+        int(item.get('fork_sequence')) if str(item.get('fork_sequence') or '').isdigit() else 0,
+        str(item.get('id') or ''),
+    ))
+    raw_messages = exclude_soft_deleted_messages(raw_messages)
+    artifact_payload_map = build_message_artifact_payload_map(raw_messages)
+
+    visible_messages = []
+    for item in filter_assistant_artifact_items(raw_messages):
+        metadata = item.get('metadata') if isinstance(item.get('metadata'), dict) else {}
+        if metadata.get('is_generated_chat_artifact', False):
+            continue
+        thread_info = metadata.get('thread_info') if isinstance(metadata.get('thread_info'), dict) else {}
+        active_thread = thread_info.get('active_thread')
+        if active_thread is True or active_thread is None:
+            visible_messages.append(item)
+
+    documents = collect_generated_documents(
+        hydrate_agent_citations_from_artifacts(visible_messages, artifact_payload_map),
+    )
+    log_event(
+        '[CONVERSATION_GENERATED_DOCUMENTS] Listed generated documents for a personal conversation.',
+        extra={
+            'conversation_id': conversation_id,
+            'message_count': len(visible_messages),
+            'document_count': len(documents),
+        },
+        debug_only=True,
+    )
+    return documents
+
+
 def _rebuild_authorized_personal_conversation_used_documents(
     user_id,
     conversation_id,
@@ -2278,6 +2332,105 @@ def get_conversation_metadata_api(conversation_id):
             print(f"Error retrieving conversation metadata: {e}")
             return jsonify({'error': 'Failed to retrieve conversation metadata'}), 500
 
+    @bp.route('/api/conversations/<conversation_id>/generated-documents', methods=['GET'])
+    @swagger_route(security=get_auth_security())
+    @login_required
+    @user_required
+    def list_personal_conversation_generated_documents_api(conversation_id):
+        """List the documents agents created in this conversation, and which the reader may download.
+
+        The personal counterpart of the shared conversation list: the same documents, read from the
+        SimpleChat upload actions' results, under the same workspace download rules.
+        """
+        user_id = get_current_user_id()
+        if not user_id:
+            return jsonify({'error': 'User not authenticated'}), 401
+
+        try:
+            conversation_item = _authorize_personal_conversation_read(user_id, conversation_id)
+            settings = get_settings()
+            documents = [
+                {
+                    'document_id': document['document_id'],
+                    'file_name': document['file_name'],
+                    'workspace_scope': document['workspace_scope'],
+                    'preview': document['preview'],
+                    'message_id': document['message_id'],
+                    'created_at': document['created_at'],
+                    'can_download': can_download_generated_document(user_id, document, settings=settings),
+                }
+                for document in _list_personal_conversation_generated_documents(conversation_item)
+            ]
+            return jsonify({'documents': documents}), 200
+        except LookupError:
+            return jsonify({'error': 'Conversation not found'}), 404
+        except PermissionError:
+            return jsonify({'error': 'Forbidden'}), 403
+        except Exception as exc:
+            log_event(
+                '[CONVERSATION_GENERATED_DOCUMENTS] Failed to list generated documents.',
+                extra={'conversation_id': conversation_id, 'exception_type': type(exc).__name__},
+                level=logging.ERROR,
+                exceptionTraceback=True,
+            )
+            return jsonify({'error': 'Failed to list generated documents'}), 500
+
+    @bp.route(
+        '/api/conversations/<conversation_id>/generated-documents/<document_id>/download',
+        methods=['GET'],
+    )
+    @swagger_route(security=get_auth_security())
+    @login_required
+    @user_required
+    def download_personal_conversation_generated_document_api(conversation_id, document_id):
+        """Download a document an agent created in this conversation, under its workspace's rules."""
+        user_id = get_current_user_id()
+        if not user_id:
+            return jsonify({'error': 'User not authenticated'}), 401
+
+        try:
+            conversation_item = _authorize_personal_conversation_read(user_id, conversation_id)
+        except LookupError:
+            return jsonify({'error': 'Conversation not found'}), 404
+        except PermissionError:
+            return jsonify({'error': 'Forbidden'}), 403
+
+        try:
+            # Only a document this conversation produced can be fetched through it.
+            document = next(
+                (
+                    candidate
+                    for candidate in _list_personal_conversation_generated_documents(conversation_item)
+                    if candidate['document_id'] == document_id
+                ),
+                None,
+            )
+            if not document:
+                return jsonify({'error': 'Document not found'}), 404
+            try:
+                document_record, group_id = authorize_generated_document_download(user_id, document)
+            except LookupError:
+                return jsonify({'error': 'Document not found or access denied'}), 404
+            return build_document_download_response(
+                document_record,
+                user_id=user_id,
+                group_id=group_id,
+            )
+        except FileNotFoundError:
+            return jsonify({'error': 'This document is not available yet.'}), 404
+        except PermissionError:
+            return jsonify({'error': 'You do not have permission to download this document'}), 403
+        except ScreeningError as error:
+            return jsonify({'error': error.public_message, 'error_code': error.code}), error.status_code
+        except Exception as exc:
+            log_event(
+                '[CONVERSATION_GENERATED_DOCUMENTS] Failed to download a generated document.',
+                extra={'conversation_id': conversation_id, 'exception_type': type(exc).__name__},
+                level=logging.ERROR,
+                exceptionTraceback=True,
+            )
+            return jsonify({'error': 'Unable to download document'}), 500
+
     @bp.route('/api/conversations/<conversation_id>/kind', methods=['GET'])
     @swagger_route(security=get_auth_security())
     @login_required
diff --git a/application/v2_ui/src/components/chat/ConversationDrawer.tsx b/application/v2_ui/src/components/chat/ConversationDrawer.tsx
index d16bb0aff..fcaf09166 100644
--- a/application/v2_ui/src/components/chat/ConversationDrawer.tsx
+++ b/application/v2_ui/src/components/chat/ConversationDrawer.tsx
@@ -2,9 +2,10 @@
 // Right-hand drawer with three modes, mirroring the legacy offcanvas that hosts both a
 // table of contents and the documents used in the conversation, plus the orchestration plan.
 //
-// Contents lists the user's turns so a long thread can be navigated; Documents lists the
-// document-level citation aggregates the server records on the conversation; Plan hosts the
-// orchestration plan surface when the feature is on.
+// Contents lists the user's turns so a long thread can be navigated; Documents lists what the
+// conversation produced (generated files and media) above the document-level citation
+// aggregates the server records on the conversation; Plan hosts the orchestration plan surface
+// when the feature is on.
 
 import { useEffect, useMemo } from 'react';
 import { clsx } from 'clsx';
@@ -19,13 +20,17 @@ import {
 } from 'lucide-react';
 import { useChatStore, type DrawerMode } from '../../stores/chatStore';
 import { useBootstrapStore } from '../../stores/bootstrapStore';
+import {
+    useConversationGeneratedDocuments,
+    useConversationGeneratedFiles,
+} from '../../stores/generatedDocumentsStore';
 import { collectConversationMedia } from '../../lib/conversationMedia';
+import { mergeGeneratedEntries } from '../../lib/conversationGeneratedFiles';
 import { EmptyState, Skeleton } from '../ui/primitives';
 import {
-    GeneratedDocumentsSection,
+    GeneratedSection,
     MediaSection,
     SectionHeading,
-    useGeneratedDocuments,
 } from './DrawerAssets';
 import { OrchestrationPlanPanel } from './OrchestrationPlanPanel';
 import type { UsedDocument } from '../../lib/types';
@@ -157,10 +162,15 @@ function DocumentRow({ document }: { document: UsedDocument }) {
 function DocumentsMode() {
     const { metadata, metadataLoading, metadataError, activeConversationId, loadMetadata } =
         useChatStore();
-    const collaborative = useChatStore((state) => state.activeConversationKind === 'collaborative');
+    const kind = useChatStore((state) => state.activeConversationKind);
     const messages = useChatStore((state) => state.messages);
     const media = useMemo(() => collectConversationMedia(messages), [messages]);
-    const generated = useGeneratedDocuments(activeConversationId, collaborative);
+    const files = useConversationGeneratedFiles();
+    const generated = useConversationGeneratedDocuments();
+    const entries = useMemo(
+        () => mergeGeneratedEntries(files, generated.documents, messages),
+        [files, generated.documents, messages],
+    );
 
     useEffect(() => {
         if (activeConversationId && !metadata && !metadataLoading && !metadataError) {
@@ -191,13 +201,15 @@ function DocumentsMode() {
         return [...merged.values()];
     }, [metadata]);
 
-    const hasAssets = generated.documents.length > 0 || Boolean(generated.error) || media.length > 0;
+    const hasAssets = entries.length > 0 || Boolean(generated.error) || media.length > 0;
     const assets = hasAssets && activeConversationId ? (
         <>
-            <GeneratedDocumentsSection
+            <GeneratedSection
                 conversationId={activeConversationId}
-                documents={generated.documents}
+                kind={kind ?? 'personal'}
+                entries={entries}
                 error={generated.error}
+                onLocate={scrollToMessage}
             />
             <MediaSection items={media} onLocate={scrollToMessage} />
         </>
@@ -232,8 +244,8 @@ function DocumentsMode() {
         return (
             <EmptyState
                 icon={<Files size={24} />}
-                title="No documents used yet"
-                description="Documents referenced while answering will be listed here."
+                title="No documents yet"
+                description="Documents used or created while answering will be listed here."
             />
         );
     }
diff --git a/application/v2_ui/src/components/chat/DrawerAssets.tsx b/application/v2_ui/src/components/chat/DrawerAssets.tsx
index 56ec7c724..0aee50f51 100644
--- a/application/v2_ui/src/components/chat/DrawerAssets.tsx
+++ b/application/v2_ui/src/components/chat/DrawerAssets.tsx
@@ -1,28 +1,49 @@
 // DrawerAssets.tsx
 // The Generated and Media sections of the conversation drawer's Documents tab.
 //
-// Generated lists the documents agents created in a shared conversation, with Download where the
-// workspace's own download rules allow it and a preview for Markdown. Media gathers every image,
-// video and audio clip the thread shows, including signed links an action fetched from a remote
-// service, which are otherwise hard to find again in a long thread. Images and clips are tiles,
-// three to a row, that open one viewer stepping through them all; recordings are players, each
-// with Download and a button that scrolls to its message.
+// Generated lists every file the conversation produced, in conversation order, for both personal
+// and shared conversations: the files a plan rendered and the exports and analysis files replies
+// wrote, read off the thread itself, and the documents agents created with the SimpleChat upload
+// actions, which the server lists along with whether the workspace's download rules let this
+// reader have them. A file that is still being written, failed or waits for approval is listed
+// with its status, and Download appears once it is ready; Markdown and files with an inline
+// preview open in a preview, and every row can scroll to the reply that produced it.
+//
+// Media gathers every image, video and audio clip the thread shows, including signed links an
+// action fetched from a remote service, which are otherwise hard to find again in a long thread.
+// Images and clips are tiles, three to a row, that open one viewer stepping through them all;
+// recordings are players, each with Download and a button that scrolls to its message.
 
 import { useCallback, useEffect, useMemo, useState } from 'react';
-import { Download, Eye, FileText, Loader2 } from 'lucide-react';
-import { ApiError } from '../../lib/apiClient';
+import { clsx } from 'clsx';
 import {
-    fetchCollaborationGeneratedDocument,
-    fetchCollaborationGeneratedDocuments,
-    type GeneratedDocument,
-} from '../../lib/collaboration';
-import { saveBlob } from '../../lib/endpoints';
+    Download,
+    Eye,
+    File as GenericFileIcon,
+    FileCode,
+    FileJson,
+    FileSpreadsheet,
+    FileText,
+    Loader2,
+    LocateFixed,
+    Presentation,
+    type LucideIcon,
+} from 'lucide-react';
 import type { ConversationMediaItem } from '../../lib/conversationMedia';
-import { useChatStore } from '../../stores/chatStore';
+import {
+    generatedFileDetails,
+    type ConversationGeneratedFile,
+    type GeneratedEntry,
+    type GeneratedFileStatus,
+} from '../../lib/conversationGeneratedFiles';
+import { downloadGeneratedArtifact, saveBlob, type ConversationKind } from '../../lib/endpoints';
+import { hasArtifactPreview, type GeneratedArtifact } from '../../lib/generatedArtifacts';
+import { fetchGeneratedDocument, type GeneratedDocument } from '../../lib/generatedDocuments';
 import { toast } from '../../stores/toastStore';
 import { Modal } from '../ui/Modal';
 import { PlainMarkdown } from '../ui/PlainMarkdown';
 import { GlassButton } from '../ui/primitives';
+import { ArtifactPreviewDialog } from './GeneratedArtifactCard';
 import { InlineAudioPlayer } from './InlineAudioPlayer';
 import { MediaViewer, type MediaViewerItem } from './MediaViewer';
 import { ImageTile, VideoTile } from './MediaTiles';
@@ -30,6 +51,43 @@ import { ImageTile, VideoTile } from './MediaTiles';
 /** Largest Markdown file previewed in the app; anything bigger is better read downloaded. */
 const PREVIEW_MAX_BYTES = 2 * 1024 * 1024;
 
+const ROW_BUTTON =
+    'shrink-0 rounded-lg p-1.5 text-text-3 transition-colors hover:bg-surface-2 hover:text-text-1 disabled:opacity-50';
+
+/** Spreadsheets, documents, decks and structured data each get an icon a person recognises. */
+const FORMAT_ICONS: Readonly<Record<string, LucideIcon>> = {
+    csv: FileSpreadsheet,
+    tsv: FileSpreadsheet,
+    xls: FileSpreadsheet,
+    xlsx: FileSpreadsheet,
+    docx: FileText,
+    pdf: FileText,
+    md: FileText,
+    txt: FileText,
+    pptx: Presentation,
+    json: FileJson,
+    xml: FileCode,
+    yaml: FileCode,
+};
+
+/** Status pills share the tones of the plan's own file cards. */
+const STATUS_TONES: Readonly<Record<Exclude<GeneratedFileStatus, 'ready'>, string>> = {
+    pending: 'bg-surface-3 text-text-2',
+    cancelled: 'bg-surface-3 text-text-2',
+    failed: 'bg-danger-soft text-danger',
+    withheld: 'bg-warn-soft text-warn',
+    unavailable: 'bg-warn-soft text-warn',
+};
+
+function FormatIcon({ format }: { format: string }) {
+    const Icon = FORMAT_ICONS[format] ?? GenericFileIcon;
+    return <Icon size={16} className="mt-0.5 shrink-0 text-text-3" aria-hidden="true" />;
+}
+
+function extensionOf(fileName: string): string {
+    return (/\.([a-z0-9]{1,8})$/i.exec(fileName)?.[1] ?? '').toLowerCase();
+}
+
 export function SectionHeading({ children }: { children: React.ReactNode }) {
     return (
         <h3 className="px-1 pb-1.5 text-[11px] font-medium tracking-wide text-text-3 uppercase">
@@ -38,71 +96,19 @@ export function SectionHeading({ children }: { children: React.ReactNode }) {
     );
 }
 
-/**
- * The generated documents of a shared conversation, refreshed as answers arrive.
- *
- * Refetched when the number of non-person messages changes, which is when an agent can have
- * created another document.
- */
-export function useGeneratedDocuments(conversationId: string | null, enabled: boolean) {
-    const answerCount = useChatStore(
-        (state) => state.messages.filter((message) => message.role !== 'user').length,
-    );
-    // Keyed by conversation, so another conversation's list is never shown while this one loads.
-    const [loaded, setLoaded] = useState<{
-        conversationId: string | null;
-        documents: GeneratedDocument[];
-        error: string | null;
-    }>({ conversationId: null, documents: [], error: null });
-
-    useEffect(() => {
-        if (!enabled || !conversationId) {
-            return;
-        }
-        const controller = new AbortController();
-        fetchCollaborationGeneratedDocuments(conversationId, controller.signal)
-            .then((result) => {
-                setLoaded({
-                    conversationId,
-                    documents: Array.isArray(result?.documents) ? result.documents : [],
-                    error: null,
-                });
-            })
-            .catch((cause: unknown) => {
-                if (controller.signal.aborted) {
-                    return;
-                }
-                // Refused or gone, as for an invitation not yet accepted: there is nothing to list.
-                const refused = cause instanceof ApiError && (cause.status === 403 || cause.status === 404);
-                setLoaded((current) => ({
-                    conversationId,
-                    documents: current.conversationId === conversationId && !refused ? current.documents : [],
-                    error: refused
-                        ? null
-                        : cause instanceof Error ? cause.message : 'Could not list generated documents.',
-                }));
-            });
-        return () => controller.abort();
-    }, [conversationId, enabled, answerCount]);
-
-    const current = enabled && loaded.conversationId === conversationId;
-    return {
-        documents: current ? loaded.documents : [],
-        error: current ? loaded.error : null,
-    };
-}
-
 function scopeLabel(document: GeneratedDocument): string {
     return document.workspace_scope === 'group' ? 'Group workspace' : 'Personal workspace';
 }
 
 function GeneratedDocumentPreview({
     conversationId,
+    kind,
     document,
     onDownload,
     onClose,
 }: {
     conversationId: string;
+    kind: ConversationKind;
     document: GeneratedDocument;
     onDownload: () => void;
     onClose: () => void;
@@ -112,7 +118,7 @@ function GeneratedDocumentPreview({
 
     useEffect(() => {
         const controller = new AbortController();
-        fetchCollaborationGeneratedDocument(conversationId, document.document_id, controller.signal)
+        fetchGeneratedDocument(conversationId, kind, document.document_id, controller.signal)
             .then(async (blob) => {
                 if (blob.size > PREVIEW_MAX_BYTES) {
                     setError('This document is too large to preview. Download it instead.');
@@ -126,7 +132,7 @@ function GeneratedDocumentPreview({
                 }
             });
         return () => controller.abort();
-    }, [conversationId, document.document_id]);
+    }, [conversationId, kind, document.document_id]);
 
     return (
         <Modal
@@ -156,31 +162,174 @@ function GeneratedDocumentPreview({
     );
 }
 
-export function GeneratedDocumentsSection({
+function LocateButton({ name, onLocate }: { name: string; onLocate: () => void }) {
+    return (
+        <button type="button" onClick={onLocate} aria-label={`Show ${name} in the conversation`}
+            title="Show in conversation" className={ROW_BUTTON}>
+            <LocateFixed size={15} />
+        </button>
+    );
+}
+
+/** A file a reply produced: a plan's rendered file, an export, or an analysis or research file. */
+function GeneratedFileRow({
+    file,
+    busy,
+    onDownload,
+    onPreview,
+    onLocate,
+}: {
+    file: ConversationGeneratedFile;
+    busy: boolean;
+    onDownload: () => void;
+    onPreview: () => void;
+    onLocate?: () => void;
+}) {
+    const ready = file.status === 'ready' && file.artifact !== null;
+    const canPreview = ready && file.artifact !== null && hasArtifactPreview(file.artifact);
+
+    return (
+        <li className="glass-flat rounded-xl p-3" data-generated-file={file.key} data-generated-file-status={file.status}>
+            <div className="flex items-start gap-2.5">
+                <FormatIcon format={file.format} />
+                <div className="min-w-0 flex-1">
+                    {ready ? (
+                        <button type="button" onClick={canPreview ? onPreview : onDownload} title={file.fileName}
+                            className="block max-w-full truncate text-left text-sm text-text-1 hover:text-accent hover:underline">
+                            {file.fileName}
+                        </button>
+                    ) : (
+                        <p className="truncate text-sm text-text-1" title={file.fileName}>
+                            {file.fileName}
+                        </p>
+                    )}
+                    <p className="mt-1 flex flex-wrap items-center gap-x-2 gap-y-1 text-xs text-text-3">
+                        <span>{generatedFileDetails(file)}</span>
+                        {file.status !== 'ready' && file.statusLabel && (
+                            <span className={clsx('rounded px-1.5 py-0.5 font-medium', STATUS_TONES[file.status])}>
+                                {file.statusLabel}
+                            </span>
+                        )}
+                    </p>
+                </div>
+                {canPreview && (
+                    <button type="button" onClick={onPreview} aria-label={`Preview ${file.fileName}`} title="Preview"
+                        className={ROW_BUTTON}>
+                        <Eye size={15} />
+                    </button>
+                )}
+                {ready && (
+                    <button type="button" disabled={busy} onClick={onDownload}
+                        aria-label={`Download ${file.fileName}`} title="Download" className={ROW_BUTTON}>
+                        {busy ? <Loader2 size={15} className="animate-spin" /> : <Download size={15} />}
+                    </button>
+                )}
+                {onLocate && <LocateButton name={file.fileName} onLocate={onLocate} />}
+            </div>
+        </li>
+    );
+}
+
+/** A document an agent created with a SimpleChat upload action, under its workspace's download rules. */
+function GeneratedDocumentRow({
+    document,
+    busy,
+    onDownload,
+    onPreview,
+    onLocate,
+}: {
+    document: GeneratedDocument;
+    busy: boolean;
+    onDownload: () => void;
+    onPreview: () => void;
+    onLocate?: () => void;
+}) {
+    const canPreview = document.can_download && document.preview === 'markdown';
+
+    return (
+        <li className="glass-flat rounded-xl p-3" data-generated-document={document.document_id}>
+            <div className="flex items-start gap-2.5">
+                <FormatIcon format={extensionOf(document.file_name)} />
+                <div className="min-w-0 flex-1">
+                    {document.can_download ? (
+                        <button type="button" onClick={canPreview ? onPreview : onDownload} title={document.file_name}
+                            className="block max-w-full truncate text-left text-sm text-text-1 hover:text-accent hover:underline">
+                            {document.file_name}
+                        </button>
+                    ) : (
+                        <p className="truncate text-sm text-text-1" title={document.file_name}>
+                            {document.file_name}
+                        </p>
+                    )}
+                    <p className="mt-1 text-xs text-text-3">
+                        {scopeLabel(document)}
+                        {!document.can_download && ' · Download not permitted'}
+                    </p>
+                </div>
+                {canPreview && (
+                    <button type="button" onClick={onPreview}
+                        aria-label={`Preview ${document.file_name}`} title="Preview" className={ROW_BUTTON}>
+                        <Eye size={15} />
+                    </button>
+                )}
+                {document.can_download && (
+                    <button type="button" disabled={busy} onClick={onDownload}
+                        aria-label={`Download ${document.file_name}`} title="Download" className={ROW_BUTTON}>
+                        {busy ? <Loader2 size={15} className="animate-spin" /> : <Download size={15} />}
+                    </button>
+                )}
+                {onLocate && <LocateButton name={document.file_name} onLocate={onLocate} />}
+            </div>
+        </li>
+    );
+}
+
+export function GeneratedSection({
     conversationId,
-    documents,
+    kind,
+    entries,
     error,
+    onLocate,
 }: {
     conversationId: string;
-    documents: GeneratedDocument[];
+    kind: ConversationKind;
+    entries: readonly GeneratedEntry[];
+    /** Why the server's list of agent-created documents could not be read, if it could not. */
     error: string | null;
+    /** Scrolls the thread to the reply that produced an entry. */
+    onLocate?: (messageId: string) => void;
 }) {
-    const [previewing, setPreviewing] = useState<GeneratedDocument | null>(null);
+    const [previewingDocument, setPreviewingDocument] = useState<GeneratedDocument | null>(null);
+    const [previewingFile, setPreviewingFile] = useState<GeneratedArtifact | null>(null);
     const [downloading, setDownloading] = useState<string | null>(null);
 
-    const download = useCallback(async (document: GeneratedDocument) => {
-        setDownloading(document.document_id);
+    const downloadDocument = useCallback(async (document: GeneratedDocument) => {
+        setDownloading(`document:${document.document_id}`);
         try {
-            const blob = await fetchCollaborationGeneratedDocument(conversationId, document.document_id);
+            const blob = await fetchGeneratedDocument(conversationId, kind, document.document_id);
             saveBlob(blob, document.file_name);
         } catch (cause) {
             toast.error(cause instanceof Error ? cause.message : 'Could not download the document.');
         } finally {
             setDownloading(null);
         }
+    }, [conversationId, kind]);
+
+    const downloadFile = useCallback(async (file: ConversationGeneratedFile) => {
+        if (!file.artifact) {
+            return;
+        }
+        setDownloading(file.key);
+        try {
+            await downloadGeneratedArtifact(file.artifact, conversationId);
+        } catch {
+            toast.error('The file could not be downloaded. Refresh the conversation and try again.');
+        } finally {
+            setDownloading(null);
+        }
     }, [conversationId]);
 
-    if (documents.length === 0 && !error) {
+    if (entries.length === 0 && !error) {
         return null;
     }
 
@@ -189,58 +338,41 @@ export function GeneratedDocumentsSection({
             <SectionHeading>Generated</SectionHeading>
             {error && <p role="alert" className="px-1 text-xs text-danger">{error}</p>}
             <ul className="space-y-2">
-                {documents.map((document) => {
-                    const canPreview = document.can_download && document.preview === 'markdown';
-                    const busy = downloading === document.document_id;
-                    const open = () => (canPreview ? setPreviewing(document) : void download(document));
-                    return (
-                        <li key={document.document_id} className="glass-flat rounded-xl p-3"
-                            data-generated-document={document.document_id}>
-                            <div className="flex items-start gap-2.5">
-                                <FileText size={16} className="mt-0.5 shrink-0 text-text-3" aria-hidden="true" />
-                                <div className="min-w-0 flex-1">
-                                    {document.can_download ? (
-                                        <button type="button" onClick={open} title={document.file_name}
-                                            className="block max-w-full truncate text-left text-sm text-text-1 hover:text-accent hover:underline">
-                                            {document.file_name}
-                                        </button>
-                                    ) : (
-                                        <p className="truncate text-sm text-text-1" title={document.file_name}>
-                                            {document.file_name}
-                                        </p>
-                                    )}
-                                    <p className="mt-1 text-xs text-text-3">
-                                        {scopeLabel(document)}
-                                        {!document.can_download && ' · Download not permitted'}
-                                    </p>
-                                </div>
-                                {canPreview && (
-                                    <button type="button" onClick={() => setPreviewing(document)}
-                                        aria-label={`Preview ${document.file_name}`} title="Preview"
-                                        className="shrink-0 rounded-lg p-1.5 text-text-3 transition-colors hover:bg-surface-2 hover:text-text-1">
-                                        <Eye size={15} />
-                                    </button>
-                                )}
-                                {document.can_download && (
-                                    <button type="button" disabled={busy} onClick={() => void download(document)}
-                                        aria-label={`Download ${document.file_name}`} title="Download"
-                                        className="shrink-0 rounded-lg p-1.5 text-text-3 transition-colors hover:bg-surface-2 hover:text-text-1 disabled:opacity-50">
-                                        {busy ? <Loader2 size={15} className="animate-spin" /> : <Download size={15} />}
-                                    </button>
-                                )}
-                            </div>
-                        </li>
+                {entries.map((entry) => {
+                    const locate = onLocate && entry.messageId ? () => onLocate(entry.messageId) : undefined;
+                    return entry.kind === 'file' ? (
+                        <GeneratedFileRow
+                            key={entry.key}
+                            file={entry.file}
+                            busy={downloading === entry.file.key}
+                            onDownload={() => void downloadFile(entry.file)}
+                            onPreview={() => setPreviewingFile(entry.file.artifact)}
+                            onLocate={locate}
+                        />
+                    ) : (
+                        <GeneratedDocumentRow
+                            key={entry.key}
+                            document={entry.document}
+                            busy={downloading === `document:${entry.document.document_id}`}
+                            onDownload={() => void downloadDocument(entry.document)}
+                            onPreview={() => setPreviewingDocument(entry.document)}
+                            onLocate={locate}
+                        />
                     );
                 })}
             </ul>
-            {previewing && (
+            {previewingDocument && (
                 <GeneratedDocumentPreview
                     conversationId={conversationId}
-                    document={previewing}
-                    onDownload={() => void download(previewing)}
-                    onClose={() => setPreviewing(null)}
+                    kind={kind}
+                    document={previewingDocument}
+                    onDownload={() => void downloadDocument(previewingDocument)}
+                    onClose={() => setPreviewingDocument(null)}
                 />
             )}
+            {previewingFile && (
+                <ArtifactPreviewDialog artifact={previewingFile} onClose={() => setPreviewingFile(null)} />
+            )}
         </section>
     );
 }
diff --git a/application/v2_ui/src/components/chat/GeneratedArtifactCard.tsx b/application/v2_ui/src/components/chat/GeneratedArtifactCard.tsx
index 97cd77a20..a0e143182 100644
--- a/application/v2_ui/src/components/chat/GeneratedArtifactCard.tsx
+++ b/application/v2_ui/src/components/chat/GeneratedArtifactCard.tsx
@@ -20,6 +20,7 @@ import { clsx } from 'clsx';
 import { Download, Eye, FileLock2, Loader2, X } from 'lucide-react';
 import { downloadGeneratedArtifact, generatedArtifactDownloadUrl } from '../../lib/endpoints';
 import { resolveGeneratedFileApproval } from '../../lib/collaboration';
+import { useGeneratedExportRunStore } from '../../stores/generatedExportRunStore';
 import { toast } from '../../stores/toastStore';
 import { GlassButton, GlassPanel } from '../ui/primitives';
 import { AssistantMarkdown } from './AssistantMarkdown';
@@ -189,9 +190,10 @@ function ArtifactPreview({ artifact }: { artifact: GeneratedArtifact }) {
  * The full-size preview for a compact card.
  *
  * Wider limits than the inline preview — fifty columns rather than four — because this is
- * opened specifically to inspect the contents before downloading.
+ * opened specifically to inspect the contents before downloading. Also opened from the
+ * Generated section of the Documents drawer.
  */
-function ArtifactPreviewDialog({
+export function ArtifactPreviewDialog({
     artifact,
     onClose,
 }: {
@@ -275,6 +277,9 @@ export function GeneratedArtifactCard({
     const [previewOpen, setPreviewOpen] = useState(false);
     const [deciding, setDeciding] = useState<'approve' | 'deny' | null>(null);
     const [downloading, setDownloading] = useState(false);
+    const recordExportRun = useGeneratedExportRunStore((state) => state.recordRun);
+    // The id the reply advertises the run under, which is what the Documents drawer looks it up by.
+    const exportRunId = initialArtifact.export_run_id;
 
     // A completed run replaces its own progress card with the files it produced.
     if (finished) {
@@ -530,10 +535,17 @@ export function GeneratedArtifactCard({
             {running && (
                 <TabularRunStatus
                     artifact={artifact}
-                    onRunUpdate={(run: GeneratedRunStatus) =>
-                        setArtifact((current) => ({ ...current, ...run }) as GeneratedArtifact)
-                    }
-                    onComplete={setFinished}
+                    onRunUpdate={(run: GeneratedRunStatus) => {
+                        setArtifact((current) => ({ ...current, ...run }) as GeneratedArtifact);
+                        recordExportRun(exportRunId, {
+                            ...(typeof run.status === 'string' ? { status: run.status } : {}),
+                            retryableFailure: Boolean(run.retryable_failure),
+                        });
+                    }}
+                    onComplete={(members: GeneratedArtifact[]) => {
+                        setFinished(members);
+                        recordExportRun(exportRunId, { status: 'completed', members });
+                    }}
                 >
                     {supporting}
                 </TabularRunStatus>
diff --git a/application/v2_ui/src/lib/collaboration.ts b/application/v2_ui/src/lib/collaboration.ts
index 10df54a6e..18a1fb28e 100644
--- a/application/v2_ui/src/lib/collaboration.ts
+++ b/application/v2_ui/src/lib/collaboration.ts
@@ -16,7 +16,7 @@
 //     conversation with its own id and leaves the original in place as the hidden source
 //     the AI actually runs in, so callers must follow the returned id.
 
-import { api, apiUrl, CREDENTIALS_MODE } from './apiClient';
+import { api, apiUrl } from './apiClient';
 import type { MessageVisualStyles } from './endpoints';
 import type {
     CollaborationConversation,
@@ -458,36 +458,6 @@ export const fetchCollaborationGeneratedDocuments = (conversationId: string, sig
 export const collaborationGeneratedDocumentUrl = (conversationId: string, documentId: string) =>
     apiUrl(`${base(conversationId)}/generated-documents/${encodeURIComponent(documentId)}/download`);
 
-/**
- * Fetch a generated document's file, for saving or previewing.
- *
- * Rejects with the server's error message, such as the reader not being allowed to download it,
- * so the reader learns why rather than receiving a broken file.
- */
-export async function fetchCollaborationGeneratedDocument(
-    conversationId: string,
-    documentId: string,
-    signal?: AbortSignal,
-): Promise<Blob> {
-    const response = await fetch(collaborationGeneratedDocumentUrl(conversationId, documentId), {
-        credentials: CREDENTIALS_MODE,
-        signal,
-    });
-    if (!response.ok) {
-        let message = `Download failed (${response.status})`;
-        try {
-            const payload = (await response.json()) as { error?: string } | null;
-            if (payload?.error) {
-                message = payload.error;
-            }
-        } catch {
-            // Not JSON: the status line is all there is to report.
-        }
-        throw new Error(message);
-    }
-    return response.blob();
-}
-
 /* -------------------------------------------------------------------------- */
 /* Images                                                                      */
 /* -------------------------------------------------------------------------- */
diff --git a/application/v2_ui/src/lib/conversationGeneratedFiles.ts b/application/v2_ui/src/lib/conversationGeneratedFiles.ts
new file mode 100644
index 000000000..b98b1392b
--- /dev/null
+++ b/application/v2_ui/src/lib/conversationGeneratedFiles.ts
@@ -0,0 +1,507 @@
+// conversationGeneratedFiles.ts
+// Every file a conversation produced, for the Generated section of the Documents drawer.
+//
+// A file reaches a thread as a card under the reply that produced it: a file an orchestration
+// plan rendered (CSV, Excel, Word, PDF, PowerPoint, Markdown, text, JSON, XML or YAML), or an
+// export, Analyze summary, comparison workbook or research ledger a turn wrote. The reply's
+// metadata is the only place the interface learns that such a file exists, so without this list
+// the drawer that gathers what a conversation used and made would report "No documents" under a
+// reply that plainly made one.
+//
+// The thread's own readers are reused, so the drawer lists exactly what the thread shows: the
+// same artifact normaliser, the same committed-output check, the same masking, saved-analysis and
+// workflow-reply rules, and the live orchestration state the file cards poll.
+//
+// Documents an agent created with the SimpleChat upload actions are listed by the server instead
+// (generatedDocuments.ts), because the server reads their ids from the tool results it stored.
+// `mergeGeneratedEntries` puts both kinds in conversation order.
+//
+// Everything in this module is pure, so it can be tested without a DOM.
+
+import type { GeneratedDocument } from './collaboration';
+import { formatFileSize } from './documentExplorer';
+import {
+    artifactDownloadPath,
+    artifactTitle,
+    readArtifactApproval,
+    readGeneratedArtifacts,
+    type GeneratedArtifact,
+} from './generatedArtifacts';
+import { readMaskState } from './masking';
+import { normalizeOrchestrationAttempt } from './orchestration';
+import {
+    committedOrchestrationArtifact,
+    isOrchestrationOutputArtifact,
+    orchestrationOutputTypeLabel,
+    type OrchestrationOutput,
+} from './orchestrationOutputs';
+import { readSavedAnalysis } from './savedAnalysis';
+import { isSupersededByWorkflowReply } from './sharedMessage';
+import type { ChatMessage, ConversationMetadata } from './types';
+
+/**
+ * Where a generated file stands, as far as the reader can act on it.
+ *
+ * Only `ready` can be downloaded. The rest are listed anyway, so a file that is still being
+ * written, failed, or waits for an owner's approval is not mistaken for one that was never made.
+ */
+export type GeneratedFileStatus =
+    | 'ready'
+    | 'pending'
+    | 'failed'
+    | 'cancelled'
+    | 'withheld'
+    | 'unavailable';
+
+export interface ConversationGeneratedFile {
+    /** Unique per file, so one advertised under several replies, such as a reused retry output, is listed once. */
+    key: string;
+    fileName: string;
+    /** Lower-case format such as `csv` or `pptx`, or '' when neither the record nor the name says. */
+    format: string;
+    /** What a person calls the file, such as "CSV file" or "Word document". */
+    typeLabel: string;
+    /** The reply whose card shows the file, for Show in conversation. */
+    messageId: string;
+    status: GeneratedFileStatus;
+    /** Short status text for the drawer; empty when the file is ready. */
+    statusLabel: string;
+    rowCount: number | null;
+    sizeBytes: number | null;
+    /** The workspace document the file was saved as, when it was saved to one. */
+    documentId: string;
+    /** What Download and Preview read. Set only while the file is ready. */
+    artifact: GeneratedArtifact | null;
+}
+
+/** What the drawer reads of a plan run's live record: the fields the thread's file cards read. */
+export interface GeneratedFileRunState {
+    outputs?: readonly OrchestrationOutput[];
+    generated_artifacts?: readonly GeneratedArtifact[];
+    outputAccessDenied?: boolean;
+}
+
+/**
+ * A background export's progress as the card that polls it last saw it.
+ *
+ * The card keeps a finished run's files in its own state, so this is how the drawer learns the
+ * run finished without the conversation being read again.
+ */
+export interface GeneratedExportRunState {
+    status?: string;
+    retryableFailure?: boolean;
+    members?: readonly GeneratedArtifact[];
+}
+
+export interface GeneratedFileSources {
+    /** Live plan runs by run id, as the orchestration store holds them. */
+    runs?: Readonly<Record<string, GeneratedFileRunState | undefined>>;
+    /** Background exports by run id, as their cards last reported them. */
+    exportRuns?: Readonly<Record<string, GeneratedExportRunState | undefined>>;
+}
+
+/** One row of the Generated section: a file a reply produced, or a document an agent created. */
+export type GeneratedEntry =
+    | { kind: 'file'; key: string; messageId: string; file: ConversationGeneratedFile }
+    | { kind: 'document'; key: string; messageId: string; document: GeneratedDocument };
+
+/** The same words the plan's own file cards use, so the drawer and the thread agree. */
+const OUTPUT_STATE_LABELS = {
+    waiting: 'Waiting',
+    rendering: 'Rendering',
+    retry_scheduled: 'Automatic retry scheduled',
+    failed: 'Failed',
+    cancelled: 'Cancelled',
+} as const;
+
+/** Spellings a format arrives under, mapped to the one the type labels know. */
+const FORMAT_ALIASES: Readonly<Record<string, string>> = {
+    markdown: 'md',
+    text: 'txt',
+    yml: 'yaml',
+};
+
+/** The SimpleChat actions that create a workspace document. Mirrors GENERATED_DOCUMENT_FUNCTIONS on the server. */
+const GENERATED_DOCUMENT_FUNCTIONS = new Set([
+    'upload_markdown_document',
+    'upload_word_document',
+    'upload_powerpoint_document',
+]);
+
+function text(value: unknown): string {
+    return typeof value === 'string' ? value.trim() : '';
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+
+function count(value: unknown): number | null {
+    const parsed = typeof value === 'number' ? value : Number.parseInt(String(value ?? ''), 10);
+    return Number.isSafeInteger(parsed) && parsed >= 0 ? parsed : null;
+}
+
+/** The file's format: the one its record declares, otherwise its extension. */
+function fileFormat(declared: unknown, fileName: string): string {
+    const format = text(declared).replace(/^\./, '').toLowerCase();
+    const resolved = format || (/\.([a-z0-9]{1,8})$/i.exec(fileName)?.[1] ?? '').toLowerCase();
+    return FORMAT_ALIASES[resolved] ?? resolved;
+}
+
+function artifactKey(artifact: GeneratedArtifact, fileName: string, format: string): string {
+    if (artifact.artifact_message_id) {
+        return `artifact:${artifact.artifact_message_id}`;
+    }
+    if (artifact.document_id) {
+        return `document:${artifact.document_id}`;
+    }
+    if (artifact.export_run_id) {
+        return `run:${artifact.export_run_id}`;
+    }
+    return `file:${fileName}:${format}`;
+}
+
+/** A file a plan was asked to produce, described exactly as its card in the thread describes it. */
+function outputFile(
+    output: OrchestrationOutput,
+    committed: readonly GeneratedArtifact[],
+    message: ChatMessage,
+    runId: string,
+    index: number,
+    accessDenied: boolean,
+): ConversationGeneratedFile {
+    const unavailable = output.available === false || accessDenied;
+    const artifact = unavailable
+        ? undefined
+        : committedOrchestrationArtifact(output, committed, text(message.conversation_id));
+    const completed = output.state === 'completed' && !unavailable;
+    const fileName = output.file_name || 'Unnamed file';
+    const format = fileFormat(output.output_format, fileName);
+
+    let status: GeneratedFileStatus;
+    let statusLabel: string;
+    if (accessDenied || (output.available === false && output.state !== 'cancelled')) {
+        status = 'unavailable';
+        statusLabel = 'Unavailable';
+    } else if (output.state === 'completed') {
+        // A completed status is not a download descriptor: without the committed record there is
+        // nothing to fetch, which the thread's card also says rather than offering a dead button.
+        status = artifact ? 'ready' : 'unavailable';
+        statusLabel = artifact ? '' : 'Download details unavailable';
+    } else if (output.state === 'waiting' || output.state === 'rendering' || output.state === 'retry_scheduled') {
+        status = 'pending';
+        statusLabel = OUTPUT_STATE_LABELS[output.state];
+    } else if (output.state === 'failed' || output.state === 'cancelled') {
+        status = output.state;
+        statusLabel = OUTPUT_STATE_LABELS[output.state];
+    } else {
+        status = 'unavailable';
+        statusLabel = 'Status unavailable';
+    }
+
+    return {
+        key: artifact
+            ? `artifact:${artifact.artifact_message_id}`
+            : `output:${runId}:${output.output_id || `#${index}`}`,
+        fileName,
+        format,
+        typeLabel: orchestrationOutputTypeLabel(format),
+        messageId: message.id,
+        status,
+        statusLabel,
+        rowCount: completed ? output.row_count : null,
+        sizeBytes: completed ? output.size_bytes : null,
+        documentId: '',
+        artifact: artifact ?? null,
+    };
+}
+
+/** An export, analysis or research file advertised on a reply. */
+function artifactFile(
+    artifact: GeneratedArtifact,
+    message: ChatMessage,
+    exportRuns: Readonly<Record<string, GeneratedExportRunState | undefined>>,
+): ConversationGeneratedFile {
+    const namedFile = text(artifact.file_name);
+    // A background export that has not finished may not know its file name yet.
+    const fileName = namedFile || artifactTitle(artifact);
+    const format = fileFormat(artifact.output_format, namedFile);
+    const approval = readArtifactApproval(artifact);
+
+    let status: GeneratedFileStatus;
+    let statusLabel: string;
+    if (artifact.background_export) {
+        const run = exportRuns[artifact.export_run_id];
+        const runStatus = text(run?.status ?? artifact.status).toLowerCase();
+        const retryable = run?.retryableFailure ?? Boolean(artifact.retryable_failure);
+        if (runStatus === 'failed' && !retryable) {
+            status = 'failed';
+            statusLabel = 'Failed';
+        } else if (runStatus === 'canceled' || runStatus === 'cancelled') {
+            status = 'cancelled';
+            statusLabel = 'Cancelled';
+        } else {
+            status = 'pending';
+            statusLabel = 'Generating';
+        }
+    } else if (approval?.isPending) {
+        status = 'withheld';
+        statusLabel = 'Awaiting approval';
+    } else if (approval?.isAutoDenied) {
+        status = 'withheld';
+        statusLabel = 'Expired';
+    } else if (approval?.isDenied) {
+        status = 'withheld';
+        statusLabel = 'Declined';
+    } else if (!artifactDownloadPath(artifact, text(message.conversation_id))) {
+        status = 'unavailable';
+        statusLabel = 'Unavailable';
+    } else {
+        status = 'ready';
+        statusLabel = '';
+    }
+
+    const running = artifact.background_export;
+    return {
+        key: artifactKey(artifact, fileName, format),
+        fileName,
+        format,
+        typeLabel: orchestrationOutputTypeLabel(format),
+        messageId: message.id,
+        status,
+        statusLabel,
+        rowCount: running ? null : count(artifact.row_count),
+        sizeBytes: running ? null : count(artifact.size_bytes),
+        documentId: text(artifact.document_id),
+        artifact: status === 'ready' ? artifact : null,
+    };
+}
+
+/**
+ * The files one message shows a card for, in the order the thread draws them: the plan's files
+ * first, then the reply's other generated files.
+ */
+export function messageGeneratedFiles(
+    message: ChatMessage,
+    sources: GeneratedFileSources = {},
+): ConversationGeneratedFile[] {
+    if (!message?.id || message.role !== 'assistant' || isSupersededByWorkflowReply(message)) {
+        return [];
+    }
+    const masks = readMaskState(message);
+    if (masks.fullyMasked) {
+        return [];
+    }
+
+    const metadata: Record<string, unknown> = isRecord(message.metadata) ? message.metadata : {};
+    const runs = sources.runs ?? {};
+    const exportRuns = sources.exportRuns ?? {};
+    const artifacts = readGeneratedArtifacts({ ...message, ...metadata });
+    const orchestration = normalizeOrchestrationAttempt(metadata.orchestration);
+    const runId = orchestration.run_id ?? '';
+    const live = runId ? runs[runId] : undefined;
+    // When the plan's file cards own its files, its committed records are not listed twice.
+    const managedOutputs = orchestration.outputs !== undefined || live?.outputs !== undefined;
+    const files: ConversationGeneratedFile[] = [];
+
+    // The thread hides a plan's file cards while any part of the reply is masked.
+    if (runId && masks.ranges.length === 0) {
+        const outputs = live?.outputs ?? orchestration.outputs ?? [];
+        const committed = live?.generated_artifacts ?? orchestration.generated_artifacts ?? artifacts;
+        outputs.forEach((output, index) => {
+            files.push(outputFile(output, committed, message, runId, index, Boolean(live?.outputAccessDenied)));
+        });
+    }
+
+    // A reply with saved Analyze findings shows its downloads only while those findings are.
+    if (metadata.saved_analysis != null) {
+        const saved = readSavedAnalysis(metadata);
+        if (!saved || saved.available === false || saved.conversation_id !== text(message.conversation_id)
+            || masks.ranges.length > 0) {
+            return files;
+        }
+    }
+
+    for (const artifact of artifacts) {
+        if (managedOutputs && isOrchestrationOutputArtifact(artifact)) {
+            continue;
+        }
+        // A finished background export is replaced by the files it produced, as its card is.
+        const members = artifact.background_export ? exportRuns[artifact.export_run_id]?.members : undefined;
+        for (const entry of members?.length ? members : [artifact]) {
+            files.push(artifactFile(entry, message, exportRuns));
+        }
+    }
+    return files;
+}
+
+/** Every file the conversation produced, oldest first, each file once. */
+export function collectConversationGeneratedFiles(
+    messages: readonly ChatMessage[],
+    sources: GeneratedFileSources = {},
+): ConversationGeneratedFile[] {
+    const seen = new Set<string>();
+    const files: ConversationGeneratedFile[] = [];
+    for (const message of messages) {
+        for (const file of messageGeneratedFiles(message, sources)) {
+            if (!seen.has(file.key)) {
+                seen.add(file.key);
+                files.push(file);
+            }
+        }
+    }
+    return files;
+}
+
+/** "CSV file · 50 rows · 1006 B", as the file's card in the thread describes it. */
+export function generatedFileDetails(file: ConversationGeneratedFile): string {
+    return [
+        file.typeLabel,
+        file.rowCount !== null ? `${file.rowCount.toLocaleString()} ${file.rowCount === 1 ? 'row' : 'rows'}` : '',
+        // An empty file is still a finished file; the shared formatter reserves its dash for unknown sizes.
+        file.sizeBytes !== null ? (file.sizeBytes === 0 ? '0 B' : formatFileSize(file.sizeBytes)) : '',
+    ].filter(Boolean).join(' · ');
+}
+
+function isGeneratedDocumentCitation(citation: unknown): boolean {
+    return isRecord(citation) && GENERATED_DOCUMENT_FUNCTIONS.has(text(citation.function_name));
+}
+
+/**
+ * Whether the conversation may hold documents an agent created with the SimpleChat upload actions.
+ *
+ * Decides whether the server is asked for them at all. A reply whose tool calls have been read
+ * answers exactly. A reply that finished in this tab carries no tool calls until the
+ * conversation is read again, and only an agent can run those actions, so an agent's reply in
+ * that state counts as a maybe.
+ */
+export function mayHaveGeneratedDocuments(messages: readonly ChatMessage[]): boolean {
+    return messages.some((message) => {
+        if (message?.role !== 'assistant') {
+            return false;
+        }
+        if (Array.isArray(message.agent_citations)) {
+            return message.agent_citations.some(isGeneratedDocumentCitation);
+        }
+        return Boolean(text(message.agent_display_name));
+    });
+}
+
+/**
+ * What the server's list of agent documents depends on in the thread, as one comparable key.
+ *
+ * The server reads the replies the thread shows and skips a fully masked one, so the list is
+ * read again whenever those change: a reply arrives or is deleted, another attempt of an answer
+ * is shown, or a reply is masked or unmasked. Counting replies is not enough, because showing
+ * another attempt or masking a reply leaves the count unchanged. A person's own message cannot
+ * hold such a document, so sending one does not cost a request.
+ */
+export function generatedDocumentsThreadKey(messages: readonly ChatMessage[]): string {
+    return JSON.stringify(
+        messages
+            .filter((message) => message?.id && message.role !== 'user')
+            .map((message) => [message.id, readMaskState(message).fullyMasked]),
+    );
+}
+
+/**
+ * The agent documents whose reply the thread shows.
+ *
+ * The server's list describes the thread as it was read, so it can briefly describe a thread the
+ * reader is no longer looking at, such as another attempt of an answer or a reply just masked.
+ * A document is kept only while its reply is shown and not fully masked, which is also what
+ * Show in conversation needs to scroll to.
+ */
+export function visibleGeneratedDocuments(
+    documents: readonly GeneratedDocument[],
+    messages: readonly ChatMessage[],
+): GeneratedDocument[] {
+    const shown = new Set(
+        messages
+            .filter((message) => message?.id && !isSupersededByWorkflowReply(message)
+                && !readMaskState(message).fullyMasked)
+            .map((message) => message.id),
+    );
+    return documents.filter((document) => shown.has(text(document?.message_id)));
+}
+
+/**
+ * Files the replies produced and documents agents created, as one list in conversation order.
+ *
+ * A file saved to a workspace and a document an agent created are the same thing when their
+ * document ids agree, so it is listed once. Documents are expected to have been narrowed to the
+ * replies the thread shows (`visibleGeneratedDocuments`).
+ */
+export function mergeGeneratedEntries(
+    files: readonly ConversationGeneratedFile[],
+    documents: readonly GeneratedDocument[],
+    messages: readonly ChatMessage[],
+): GeneratedEntry[] {
+    const position = new Map<string, number>();
+    messages.forEach((message, index) => {
+        if (message?.id && !position.has(message.id)) {
+            position.set(message.id, index);
+        }
+    });
+
+    const seen = new Set<string>();
+    const entries: GeneratedEntry[] = [];
+    for (const file of files) {
+        const identity = file.documentId ? `document:${file.documentId}` : file.key;
+        if (!seen.has(identity)) {
+            seen.add(identity);
+            entries.push({ kind: 'file', key: file.key, messageId: file.messageId, file });
+        }
+    }
+    for (const document of documents) {
+        const documentId = text(document?.document_id);
+        const identity = `document:${documentId}`;
+        if (documentId && !seen.has(identity)) {
+            seen.add(identity);
+            entries.push({ kind: 'document', key: identity, messageId: text(document.message_id), document });
+        }
+    }
+
+    // A message the thread no longer holds sorts last rather than disappearing.
+    const order = (entry: GeneratedEntry) => position.get(entry.messageId) ?? Number.MAX_SAFE_INTEGER;
+    return entries
+        .map((entry, index) => ({ entry, index }))
+        .sort((left, right) => order(left.entry) - order(right.entry) || left.index - right.index)
+        .map(({ entry }) => entry);
+}
+
+/**
+ * How many documents the Documents button counts: the ones answers used and the ones the
+ * conversation produced, each once. Media is not counted; it has its own section.
+ */
+export function countConversationDocuments(
+    metadata: Pick<ConversationMetadata, 'used_documents' | 'legacy_used_documents' | 'linked_workspace_documents'>
+        | null
+        | undefined,
+    files: readonly ConversationGeneratedFile[],
+    documents: readonly GeneratedDocument[],
+): number {
+    const keys = new Set<string>();
+    for (const list of [
+        metadata?.used_documents,
+        metadata?.legacy_used_documents,
+        metadata?.linked_workspace_documents,
+    ]) {
+        for (const document of list ?? []) {
+            const documentId = String(document?.document_id ?? '').trim();
+            if (documentId) {
+                keys.add(`document:${documentId}`);
+            }
+        }
+    }
+    for (const file of files) {
+        keys.add(file.documentId ? `document:${file.documentId}` : file.key);
+    }
+    for (const document of documents) {
+        const documentId = text(document?.document_id);
+        if (documentId) {
+            keys.add(`document:${documentId}`);
+        }
+    }
+    return keys.size;
+}
diff --git a/application/v2_ui/src/lib/generatedDocuments.ts b/application/v2_ui/src/lib/generatedDocuments.ts
new file mode 100644
index 000000000..d5e9f4b0e
--- /dev/null
+++ b/application/v2_ui/src/lib/generatedDocuments.ts
@@ -0,0 +1,72 @@
+// generatedDocuments.ts
+// The documents agents created in a conversation with the SimpleChat upload actions.
+//
+// A shared conversation and a personal one list these behind different routes, because each is
+// authorized against its own kind of conversation: participation for a shared one, ownership for
+// a personal one. Callers name the conversation and its kind and this module picks the route, so
+// a list read from one family is never downloaded through the other.
+
+import { api, apiUrl, CREDENTIALS_MODE } from './apiClient';
+import {
+    collaborationGeneratedDocumentUrl,
+    fetchCollaborationGeneratedDocuments,
+    type GeneratedDocument,
+} from './collaboration';
+import type { ConversationKind } from './endpoints';
+
+export type { GeneratedDocument };
+
+const personalGeneratedDocumentsPath = (conversationId: string) =>
+    `/api/conversations/${encodeURIComponent(conversationId)}/generated-documents`;
+
+export function fetchGeneratedDocuments(
+    conversationId: string,
+    kind: ConversationKind,
+    signal?: AbortSignal,
+): Promise<{ documents: GeneratedDocument[] }> {
+    return kind === 'collaborative'
+        ? fetchCollaborationGeneratedDocuments(conversationId, signal)
+        : api.get<{ documents: GeneratedDocument[] }>(personalGeneratedDocumentsPath(conversationId), signal);
+}
+
+/** Where one generated document downloads from; the same request also feeds the preview. */
+export function generatedDocumentDownloadUrl(
+    conversationId: string,
+    kind: ConversationKind,
+    documentId: string,
+): string {
+    return kind === 'collaborative'
+        ? collaborationGeneratedDocumentUrl(conversationId, documentId)
+        : apiUrl(`${personalGeneratedDocumentsPath(conversationId)}/${encodeURIComponent(documentId)}/download`);
+}
+
+/**
+ * Fetch a generated document's file, for saving or previewing.
+ *
+ * Rejects with the server's error message, such as the reader not being allowed to download it,
+ * so the reader learns why rather than receiving a broken file.
+ */
+export async function fetchGeneratedDocument(
+    conversationId: string,
+    kind: ConversationKind,
+    documentId: string,
+    signal?: AbortSignal,
+): Promise<Blob> {
+    const response = await fetch(generatedDocumentDownloadUrl(conversationId, kind, documentId), {
+        credentials: CREDENTIALS_MODE,
+        signal,
+    });
+    if (!response.ok) {
+        let message = `Download failed (${response.status})`;
+        try {
+            const payload = (await response.json()) as { error?: string } | null;
+            if (payload?.error) {
+                message = payload.error;
+            }
+        } catch {
+            // Not JSON: the status line is all there is to report.
+        }
+        throw new Error(message);
+    }
+    return response.blob();
+}
diff --git a/application/v2_ui/src/pages/ChatPage.tsx b/application/v2_ui/src/pages/ChatPage.tsx
index 715c912e2..997f61898 100644
--- a/application/v2_ui/src/pages/ChatPage.tsx
+++ b/application/v2_ui/src/pages/ChatPage.tsx
@@ -1,7 +1,7 @@
 // ChatPage.tsx
 // Chat surface: header, message thread, composer, and the right-hand drawer.
 
-import { useEffect, useRef, useState } from 'react';
+import { useEffect, useMemo, useRef, useState } from 'react';
 import { useSearchParams } from 'react-router-dom';
 import { clsx } from 'clsx';
 import {
@@ -16,6 +16,10 @@ import {
 import { useChatStore, type DrawerMode } from '../stores/chatStore';
 import { useCollaborationStore } from '../stores/collaborationStore';
 import { useBootstrapStore } from '../stores/bootstrapStore';
+import {
+    useConversationGeneratedDocuments,
+    useConversationGeneratedFiles,
+} from '../stores/generatedDocumentsStore';
 import { useUiStore } from '../stores/uiStore';
 import { useImageProposalStore } from '../stores/imageProposalStore';
 import {
@@ -24,6 +28,7 @@ import {
     useOrchestrationStore,
 } from '../stores/orchestrationStore';
 import { enabledSteps, isPlanAwaitingApproval } from '../lib/orchestrationPlan';
+import { countConversationDocuments } from '../lib/conversationGeneratedFiles';
 import { resumeOrchestrationForConversation } from '../lib/orchestrationResume';
 import {
     hasWorkflowResultLaunch,
@@ -236,19 +241,15 @@ function ChatHeader({ onOpenDetails }: { onOpenDetails: () => void }) {
     const shareSource = metadata ?? active;
     const shareable = collaborationEnabled && canShareConversation(shareSource);
 
-    // Counted from loaded metadata so the badge stays honest: it shows nothing rather
-    // than a guess until the real document list has arrived.
-    const documentCount = metadata
-        ? new Set(
-              [
-                  ...(metadata.used_documents ?? []),
-                  ...(metadata.legacy_used_documents ?? []),
-                  ...(metadata.linked_workspace_documents ?? []),
-              ]
-                  .map((document) => String(document?.document_id ?? '').trim())
-                  .filter(Boolean),
-          ).size
-        : null;
+    // Counted from what has loaded so the badge stays honest: it shows nothing rather than a guess
+    // until the document list, or a reply that produced a file, has arrived. Generated files and
+    // documents agents created count alongside the documents answers used, each once.
+    const generatedFiles = useConversationGeneratedFiles();
+    const { documents: generatedDocuments } = useConversationGeneratedDocuments();
+    const documentCount = useMemo(
+        () => countConversationDocuments(metadata, generatedFiles, generatedDocuments),
+        [metadata, generatedFiles, generatedDocuments],
+    );
 
     const toggle = (mode: Exclude<DrawerMode, null>) =>
         setDrawerMode(drawerMode === mode ? null : mode);
diff --git a/application/v2_ui/src/stores/chatStore.ts b/application/v2_ui/src/stores/chatStore.ts
index 7660186fc..c6208faac 100644
--- a/application/v2_ui/src/stores/chatStore.ts
+++ b/application/v2_ui/src/stores/chatStore.ts
@@ -3543,7 +3543,7 @@ export const useChatStore = create<ChatState>((set, get) => ({
         // The Documents drawer reads the conversation's used-document list rather than the
         // message's citations, and the server only extends that list once the run finishes.
         // Without this refetch the drawer keeps reporting the state it was fetched in --
-        // "No documents used yet" under an answer that plainly used one.
+        // "No documents yet" under an answer that plainly used one.
         if (event.augmented) {
             void get().loadMetadata(conversationId);
         }
diff --git a/application/v2_ui/src/stores/generatedDocumentsStore.ts b/application/v2_ui/src/stores/generatedDocumentsStore.ts
new file mode 100644
index 000000000..ce781a18c
--- /dev/null
+++ b/application/v2_ui/src/stores/generatedDocumentsStore.ts
@@ -0,0 +1,167 @@
+// generatedDocumentsStore.ts
+// What the open conversation produced, shared by the Documents drawer and the header.
+//
+// The Generated section of the Documents drawer lists these and the badge on the drawer's button
+// counts them, and both are on screen while a conversation is open. Two kinds are gathered:
+//
+// - Files the replies produced: plan outputs, exports and analysis files. They are read off the
+//   loaded messages and the live run state, with no request of their own.
+// - Documents agents created with the SimpleChat upload actions, which the server lists. One copy
+//   of that list is kept here, so opening the drawer never repeats a request the badge already
+//   made, and the two cannot disagree about what the conversation produced. It is read again
+//   whenever the replies the thread shows change, which is when an agent can have created another
+//   document or one stopped being shown, and only for a conversation that can hold one at all.
+//   A shared conversation's list is only read once the reader has joined it, because the server
+//   refuses an invitation that has not been accepted; joining reads it straight away.
+
+import { useEffect, useMemo } from 'react';
+import { create } from 'zustand';
+import { ApiError } from '../lib/apiClient';
+import {
+    collectConversationGeneratedFiles,
+    generatedDocumentsThreadKey,
+    mayHaveGeneratedDocuments,
+    visibleGeneratedDocuments,
+    type ConversationGeneratedFile,
+} from '../lib/conversationGeneratedFiles';
+import type { ConversationKind } from '../lib/endpoints';
+import { fetchGeneratedDocuments, type GeneratedDocument } from '../lib/generatedDocuments';
+import { useChatStore } from './chatStore';
+import { useCollaborationStore } from './collaborationStore';
+import { useGeneratedExportRunStore } from './generatedExportRunStore';
+import { useOrchestrationStore } from './orchestrationStore';
+
+const EMPTY_DOCUMENTS: GeneratedDocument[] = [];
+
+interface GeneratedDocumentsState {
+    /**
+     * The request the list answers or is waiting on: the conversation, its kind, and what of it the
+     * server's answer depends on. Null after a failure, so the next reader to mount tries again.
+     */
+    requestKey: string | null;
+    conversationId: string | null;
+    documents: GeneratedDocument[];
+    error: string | null;
+    load: (conversationId: string, kind: ConversationKind, threadKey: string) => void;
+    /** Forget the list, so the conversation is read afresh the next time it needs one. */
+    clear: () => void;
+}
+
+let inFlight: AbortController | null = null;
+
+export const useGeneratedDocumentsStore = create<GeneratedDocumentsState>((set, get) => ({
+    requestKey: null,
+    conversationId: null,
+    documents: [],
+    error: null,
+    load: (conversationId, kind, threadKey) => {
+        const requestKey = JSON.stringify([conversationId, kind, threadKey]);
+        if (get().requestKey === requestKey) {
+            return;
+        }
+        inFlight?.abort();
+        const controller = new AbortController();
+        inFlight = controller;
+        // Keyed by conversation, so another conversation's list is never shown while this one loads.
+        set((state) => (state.conversationId === conversationId
+            ? { requestKey }
+            : { requestKey, conversationId, documents: [], error: null }));
+
+        fetchGeneratedDocuments(conversationId, kind, controller.signal)
+            .then((result) => {
+                if (get().requestKey === requestKey) {
+                    set({ documents: Array.isArray(result?.documents) ? result.documents : [], error: null });
+                }
+            })
+            .catch((cause: unknown) => {
+                if (controller.signal.aborted || get().requestKey !== requestKey) {
+                    return;
+                }
+                // Refused or gone: there is nothing to list. Neither answer is kept as final, so a
+                // reader who mounts later, such as the drawer being reopened, asks again.
+                const refused = cause instanceof ApiError && (cause.status === 403 || cause.status === 404);
+                set((state) => ({
+                    requestKey: null,
+                    documents: refused ? [] : state.documents,
+                    error: refused
+                        ? null
+                        : cause instanceof Error ? cause.message : 'Could not list generated documents.',
+                }));
+            })
+            .finally(() => {
+                if (inFlight === controller) {
+                    inFlight = null;
+                }
+            });
+    },
+    clear: () => {
+        const state = get();
+        if (state.requestKey === null && state.conversationId === null) {
+            return;
+        }
+        inFlight?.abort();
+        inFlight = null;
+        set({ requestKey: null, conversationId: null, documents: [], error: null });
+    },
+}));
+
+/**
+ * The documents agents created in the open conversation and the thread still shows, kept current
+ * as replies arrive, attempts change or replies are masked.
+ */
+export function useConversationGeneratedDocuments(): { documents: GeneratedDocument[]; error: string | null } {
+    const conversationId = useChatStore((state) => state.activeConversationId);
+    const kind = useChatStore((state) => state.activeConversationKind);
+    const messages = useChatStore((state) => state.messages);
+    // Who the reader is in a shared conversation, once that has loaded. Null while it has not, and
+    // while an invitation can still be accepted, because the server refuses the list until then.
+    const access = useCollaborationStore((state) => {
+        if (kind !== 'collaborative') {
+            return 'personal';
+        }
+        const conversation = state.conversation;
+        if (!conversation || conversation.id !== conversationId || conversation.can_accept_invite) {
+            return null;
+        }
+        return String(conversation.membership_status ?? 'member');
+    });
+    const threadKey = useMemo(() => generatedDocumentsThreadKey(messages), [messages]);
+    const wanted = useMemo(() => mayHaveGeneratedDocuments(messages), [messages]) && access !== null;
+    const loadedFor = useGeneratedDocumentsStore((state) => state.conversationId);
+    const documents = useGeneratedDocumentsStore((state) => state.documents);
+    const error = useGeneratedDocumentsStore((state) => state.error);
+    const visible = useMemo(() => visibleGeneratedDocuments(documents, messages), [documents, messages]);
+
+    useEffect(() => {
+        const store = useGeneratedDocumentsStore.getState();
+        if (conversationId && kind && wanted) {
+            store.load(conversationId, kind, `${access}:${threadKey}`);
+        } else {
+            // Nothing to list here. Forgetting the last list means a conversation opened again
+            // later is read afresh, rather than shown as it was when it was left.
+            store.clear();
+        }
+    }, [conversationId, kind, wanted, access, threadKey]);
+
+    const current = Boolean(conversationId && wanted && loadedFor === conversationId);
+    return {
+        documents: current ? visible : EMPTY_DOCUMENTS,
+        error: current ? error : null,
+    };
+}
+
+/**
+ * Every file the open conversation's replies produced, as the thread currently shows them.
+ *
+ * Follows the live plan runs and background exports too, so a file that finishes while the
+ * conversation is open changes state here as its card in the thread does.
+ */
+export function useConversationGeneratedFiles(): ConversationGeneratedFile[] {
+    const messages = useChatStore((state) => state.messages);
+    const runs = useOrchestrationStore((state) => state.runRecovery);
+    const exportRuns = useGeneratedExportRunStore((state) => state.runs);
+    return useMemo(
+        () => collectConversationGeneratedFiles(messages, { runs, exportRuns }),
+        [messages, runs, exportRuns],
+    );
+}
diff --git a/application/v2_ui/src/stores/generatedExportRunStore.ts b/application/v2_ui/src/stores/generatedExportRunStore.ts
new file mode 100644
index 000000000..ace387796
--- /dev/null
+++ b/application/v2_ui/src/stores/generatedExportRunStore.ts
@@ -0,0 +1,27 @@
+// generatedExportRunStore.ts
+// What the export cards have learned about background export runs, shared with the drawer.
+//
+// A large export runs in the background. Its card in the thread polls the run and, once the run
+// finishes, replaces itself with the files it produced. That happens in the card's own state,
+// which the Documents drawer cannot see, so without this the drawer would keep listing a finished
+// export as still generating until the conversation was opened again.
+
+import { create } from 'zustand';
+import type { GeneratedExportRunState } from '../lib/conversationGeneratedFiles';
+
+interface GeneratedExportRunStore {
+    /** Keyed by export run id. */
+    runs: Record<string, GeneratedExportRunState>;
+    recordRun: (runId: string, patch: GeneratedExportRunState) => void;
+}
+
+export const useGeneratedExportRunStore = create<GeneratedExportRunStore>((set) => ({
+    runs: {},
+    recordRun: (runId, patch) => {
+        const key = runId.trim();
+        if (!key) {
+            return;
+        }
+        set((state) => ({ runs: { ...state.runs, [key]: { ...state.runs[key], ...patch } } }));
+    },
+}));
diff --git a/docs/explanation/features/V2_COLLABORATION_UX.md b/docs/explanation/features/V2_COLLABORATION_UX.md
index f7e79252f..0a4f2a2f1 100644
--- a/docs/explanation/features/V2_COLLABORATION_UX.md
+++ b/docs/explanation/features/V2_COLLABORATION_UX.md
@@ -126,6 +126,15 @@ download rules for the reader, whichever group they currently have active:
 The Markdown preview fetches the same route and renders it with `PlainMarkdown`, which does not
 render raw HTML. Word and PowerPoint files download only.
 
+Since 0.261.302 personal conversations list these documents too, through
+`/api/conversations/<id>/generated-documents` and its `/download` route, which require the
+conversation's owner and apply the same reader and download rules. The **Generated** section also
+lists every file a reply produced, such as a CSV a plan rendered, an export or an Analyze summary,
+with its status. The list is only requested for a thread whose replies ran an upload action or came
+from an agent, and in a shared conversation only once the reader has joined; joining reads it
+straight away. See the
+[Documents drawer generated files fix](../fixes/DOCUMENTS_DRAWER_GENERATED_FILES_FIX.md).
+
 ### Media
 
 `collectConversationMedia` (`lib/conversationMedia.ts`) lists images from image messages and from
diff --git a/docs/explanation/fixes/DOCUMENTS_DRAWER_GENERATED_FILES_FIX.md b/docs/explanation/fixes/DOCUMENTS_DRAWER_GENERATED_FILES_FIX.md
new file mode 100644
index 000000000..fd1ca03f5
--- /dev/null
+++ b/docs/explanation/fixes/DOCUMENTS_DRAWER_GENERATED_FILES_FIX.md
@@ -0,0 +1,230 @@
+# Documents Drawer Generated Files Fix
+
+**Version: 0.261.302**
+
+Fixed in version: **0.261.302**, recorded in
+`application/single_app/config.py`.
+
+This affects the React V2 branch (`paullizer-react-v2-ui`) and deployments built
+from it.
+
+## Issue
+
+In V2 chat, a user asked for a CSV file of every state and its capital. Orchestrate
+rendered `us_states_and_capitals.csv`, and the reply showed a **Files** card marked
+**Completed** with **Download CSV**. The conversation drawer's **Documents** tab still
+said "No documents used yet".
+
+Images a conversation produced did appear in the drawer. The CSV did not, and neither
+did any other file a reply produced: a Word, PDF or PowerPoint file a plan rendered,
+an export, or an Analyze summary.
+
+## Root cause
+
+The **Documents** tab had three sources:
+
+- **Used in answers**: the document citation aggregates stored on the conversation
+  (`used_documents`, `legacy_used_documents` and `linked_workspace_documents`).
+- **Media**: every image, video and audio clip the thread shows. This is why images
+  appeared.
+- **Generated**: added in 0.261.255 for shared conversations only. It listed the
+  documents agents created with the SimpleChat upload actions (Markdown, Word and
+  PowerPoint), which `/api/collaboration/conversations/<id>/generated-documents` reads
+  from the actions' results. `useGeneratedDocuments` was turned off for any other
+  conversation.
+
+A file a reply produces is recorded on the reply, not on the conversation. A plan's
+files are in `metadata.orchestration.outputs`, with the committed download records in
+`generated_artifacts`. Exports, Analyze summaries, comparison workbooks and research
+ledgers are in `generated_tabular_outputs` and `generated_analysis_artifacts`. Only the
+cards in the thread read these, so nothing passed them to the drawer. In a personal
+conversation, a document an agent created with a SimpleChat upload action was not
+listed anywhere.
+
+## Changes
+
+### Every file a reply produced is listed, in any conversation
+
+`lib/conversationGeneratedFiles.ts` reads the loaded messages with the same readers the
+thread's file cards use: `readGeneratedArtifacts`, `normalizeOrchestrationAttempt`
+with `committedOrchestrationArtifact`, and the live plan run state the cards poll. The
+drawer therefore lists exactly what the thread shows:
+
+- A fully masked reply and a reply a workflow reply replaced list nothing.
+- A plan's files are hidden while any part of their reply is masked, as their cards are.
+- Downloads under saved Analyze findings follow those findings' availability.
+- A plan's committed file is listed once, as its file card, not again as a loose record.
+- A file several replies show, such as one a retry reused, is listed once, under the
+  first reply that showed it.
+
+Every format a plan can render is covered: CSV, Excel, Word, PDF, PowerPoint, Markdown,
+text, JSON, XML and YAML, plus any format an export or analysis file declares.
+
+A file that is not ready is listed with its status rather than left out, so it is not
+mistaken for one that was never made. Only a ready file offers **Download**.
+
+| Status shown | When |
+| --- | --- |
+| None (ready) | The file can be downloaded. |
+| Waiting, Rendering, Automatic retry scheduled | A plan's file is still being produced. |
+| Generating | A background export is still running. |
+| Failed, Cancelled | The file was not produced. |
+| Awaiting approval, Declined, Expired | A file generated in a shared conversation is held for the owner's approval, or was refused. |
+| Unavailable, Download details unavailable, Status unavailable | Current access to the file cannot be confirmed, or its download record or state has not arrived. |
+
+Downloads use the routes the cards already use: `/api/chat_artifacts/download`, with
+its approval and publication checks, or `/api/workspace_documents/download` for a copy
+saved to the personal workspace.
+
+### A background export that finishes updates the drawer
+
+A background export's card polls the run and replaces itself with the files the run
+produced. It now also records the run's status and those files in
+`stores/generatedExportRunStore.ts`, which the drawer reads. Without this, the drawer
+would list a finished export as still generating until the conversation was reopened.
+
+### Documents agents create are listed in personal conversations
+
+Two routes in `route_backend_conversations.py` give personal conversations what shared
+conversations already had:
+
+- `GET /api/conversations/<conversation_id>/generated-documents`
+- `GET /api/conversations/<conversation_id>/generated-documents/<document_id>/download`
+
+Both require sign-in and a user role, and call
+`_authorize_personal_conversation_read` before anything is read, so only the
+conversation's owner gets an answer. `_list_personal_conversation_generated_documents`
+then reads the messages the thread shows, filtered as `/api/get_messages` filters them:
+deleted messages, the assistant artifact store, hidden generated chat files and replaced
+thread attempts are left out. A citation stored in compact form is rebuilt from its
+artifact record first, because the created document's id is in the full tool result.
+`collect_generated_documents`, the shared conversation's reader, does the rest, so both
+kinds of conversation list documents by the same rules, and a masked message's
+documents stay hidden.
+
+The list carries no group ids. The download serves only a document this conversation
+produced, through `authorize_generated_document_download` and
+`build_document_download_response`, so the workspace's own download rules apply: the
+document's owner with personal downloads allowed, or a document-managing group role with
+downloads allowed for that group. Failures return fixed messages, and a content
+screening refusal returns its public message.
+
+`lib/generatedDocuments.ts` picks the personal or shared route by the conversation's
+kind, so a list read from one family of routes is never downloaded through the other.
+The list is requested only when the thread can hold such a document: a reply whose tool
+calls include an upload action, or an agent's reply that finished in this tab, whose
+tool calls are not loaded until the conversation is read again.
+
+It is read again whenever the replies the thread shows change: a reply arrives or is
+deleted, another attempt of an answer is shown, or a reply is masked or unmasked. A
+reply count would miss the last two, because they leave the count unchanged. Only
+documents whose reply the thread shows, and does not fully mask, are listed or counted,
+so a document from an attempt that is no longer shown never lingers with a **Show in
+conversation** that leads nowhere. A shared conversation's list is read only once the
+reader has joined: while an invitation can still be accepted the server would refuse
+it, so it is not requested, and joining reads it straight away. A refused or failed
+read is not kept, so the drawer asks again the next time it opens, and a conversation
+opened again after another one is read afresh.
+
+### One Generated section, counted by the Documents button
+
+The drawer's **Generated** section merges both kinds into one list in conversation
+order. Each row shows an icon for its kind of file, its name, its type with rows and
+size (for example "CSV file · 50 rows · 1006 B"), and a status when it is not ready.
+**Preview** opens Markdown and any file that carries a preview, **Download** saves a
+ready file, and **Show in conversation** scrolls to the reply that produced it.
+
+The badge on the header's **Documents** button counts the documents answers used plus
+every file and document the conversation produced, each once by document id. Media is
+not counted. `stores/generatedDocumentsStore.ts` holds one copy of the agent-document
+list for the badge and the drawer, so opening the drawer does not request it again.
+
+The empty state now reads "No documents yet" and "Documents used or created while
+answering will be listed here."
+
+### Files modified
+
+| File | Change |
+| --- | --- |
+| `application/single_app/route_backend_conversations.py` | Personal generated-documents list and download routes, and the visible-message reader behind them. |
+| `application/single_app/functions_collaboration_generated_documents.py` | Docstring covers personal conversations. |
+| `application/single_app/config.py` | Version `0.261.302`. |
+| `application/v2_ui/src/lib/conversationGeneratedFiles.ts` | New. Collects every file the replies produced, merges agent documents, gates the request and counts the badge. |
+| `application/v2_ui/src/lib/generatedDocuments.ts` | New. Reads and downloads agent documents through the personal or shared route. |
+| `application/v2_ui/src/lib/collaboration.ts` | The shared conversation's file fetch moved to `generatedDocuments.ts`. |
+| `application/v2_ui/src/stores/generatedDocumentsStore.ts` | New. The shared agent-document list and the generated-files hook. |
+| `application/v2_ui/src/stores/generatedExportRunStore.ts` | New. Background export progress shared with the drawer. |
+| `application/v2_ui/src/components/chat/DrawerAssets.tsx` | One Generated section for both kinds of file. |
+| `application/v2_ui/src/components/chat/ConversationDrawer.tsx` | Uses the new section and empty-state text. |
+| `application/v2_ui/src/components/chat/GeneratedArtifactCard.tsx` | Shares its preview dialog and records background export progress. |
+| `application/v2_ui/src/pages/ChatPage.tsx` | The Documents badge counts generated files. |
+| `docs/reference/chat-controls.md` | New Documents drawer section. |
+| `docs/reference/logging-tags.md` | New `[CONVERSATION_GENERATED_DOCUMENTS]` tag. |
+
+No setting, deployment or data change is needed.
+
+## Validation
+
+### Tests
+
+- `functional_tests/test_v2_drawer_generated_files_logic.mjs` runs the real collector.
+  It covers the reported CSV with its download route, each format a plan can render
+  with its label, every status, live run state over the saved snapshot, exports,
+  Analyze files, background exports, approval-held files, masked and replaced replies,
+  saved Analyze gating, de-duplication, ordering with agent documents, the request gate,
+  what makes the agent-document list read again, which agent documents stay listed,
+  and the badge count.
+- `functional_tests/test_personal_conversation_generated_documents.py` runs the real
+  route helper against a fake container with the real message, deletion and
+  generated-document readers. It checks that deleted, replaced, masked and hidden
+  messages are skipped and that compact citations are rebuilt. It also checks the
+  routes' decorators, that the owner check runs before any read, that downloads are
+  scoped to the conversation, and that no response carries exception text.
+- `ui_tests/test_v2_drawer_generated_files.py` mounts the real drawer and chat page in
+  Chromium with production CSS. It lists the reported CSV, a rendering PDF, a failed
+  workbook, an agent's Word brief and an Analyze summary in conversation order. It
+  downloads the CSV and the brief through their routes and previews the summary. It
+  scrolls to the reply that produced a file, keeps the empty state, and checks that the
+  header badge counts generated files while sharing one request with the drawer. A
+  background export that finishes while the conversation is open becomes downloadable
+  in the drawer. Showing another attempt or masking a reply re-reads the agent documents
+  and hides what the thread no longer shows; a refused list is asked again when the
+  drawer reopens; and returning to a conversation reads its list afresh.
+- `ui_tests/test_v2_collaboration_ux.py` now gives its reply the upload citations its
+  documents come from, which the shared list requires. It also checks that an invited
+  reader's drawer makes no request the server would refuse, and that joining lists the
+  documents without reopening the drawer.
+
+These regression tests were checked against the code before the fix: the attempt and
+masking, refused-list and invitation tests fail on the earlier version of the shared
+store, and the background export test fails without the export card's report to the
+drawer.
+
+The route policy suites, the existing drawer, media and shared generated-document
+tests, the V2 type check and production build, and the related V2 UI suites (planning
+retry, orchestration outputs, media galleries, new chat reset, sidebar scroll and saved
+output publication) pass.
+
+### Before and after
+
+| Before | After |
+| --- | --- |
+| A plan's CSV, Word, PDF or PowerPoint file was only on its card in the thread. | It is listed in the drawer with its status, and downloads from there when ready. |
+| Exports and Analyze files were only on their cards. | They are listed too. |
+| Agent documents were listed in shared conversations only. | They are listed in personal conversations as well. |
+| The Documents badge counted only documents answers used. | It also counts what the conversation produced. |
+
+## Limitations
+
+- The classic chat page is unchanged.
+- A background export's progress reaches the drawer through its card in the thread,
+  which polls the run while the conversation is open.
+- Whether an agent document can be downloaded is decided when the list is read, so a
+  change to the download settings shows the next time it is read, for example when the
+  conversation is opened again. The download itself always rechecks.
+
+## Related
+
+- [V2 shared conversation experience](../features/V2_COLLABORATION_UX.md)
+- [V2 media galleries and viewer](../features/V2_MEDIA_GALLERIES_AND_VIEWER.md)
+- [Chat controls reference](../../reference/chat-controls.md)
diff --git a/docs/reference/chat-controls.md b/docs/reference/chat-controls.md
index 7d0c72509..cca942a46 100644
--- a/docs/reference/chat-controls.md
+++ b/docs/reference/chat-controls.md
@@ -358,7 +358,7 @@ These controls exist only in the V2 interface, so they are not part of the gener
 
 ## Shared conversations (V2 interface)
 
-These controls exist only in the V2 interface, so they are not part of the generated inventory above, which is taken from the classic chat page. They make a conversation with several people and agents readable at a glance: who a message is for, which agents are working, and what the conversation has produced. See [V2 shared conversation experience]({{ '/explanation/features/V2_COLLABORATION_UX/' | relative_url }}) for the full description.
+These controls exist only in the V2 interface, so they are not part of the generated inventory above, which is taken from the classic chat page. They make a conversation with several people and agents readable at a glance: who a message is for and which agents are working. See [V2 shared conversation experience]({{ '/explanation/features/V2_COLLABORATION_UX/' | relative_url }}) for the full description.
 
 | Control | What it does | Why you would use it | Enabled by |
 | --- | --- | --- | --- |
@@ -366,7 +366,15 @@ These controls exist only in the V2 interface, so they are not part of the gener
 | Mention chips | Show who the message is for: any number of people and at most one model or agent. Picking a second agent replaces the first, and each chip has a remove button. When you send, the names are placed in front of the message, which is how the server, the classic interface and the assistant read them. A message of chips alone is sent as a ping. | Use them to check who will be notified and which agent will answer before sending. | [`enable_collaborative_conversations`]({{ '/admin/chat/' | relative_url }}) |
 | Mention pills on a message | Show the agent that was asked and the people who were named as pills above the message text, with your own name highlighted. The `@Name` text is removed from what is displayed, including where a reply quotes the message; the stored message keeps it. | Use them to see at a glance who a message was for, the same way a reply shows what it answers. | [`enable_collaborative_conversations`]({{ '/admin/chat/' | relative_url }}) |
 | Agent activity line | Shows one slim line at the end of the thread for each running request: which agent, who asked, how long it has been running, and what it is doing in plain words, such as "Looking up order status", "Asking Data Analyst" or "Writing the answer". Everyone in the conversation sees it, several can run at once, and it replaces the large "Thinking" bubble in shared conversations. | Use it to know an agent is still working, and on what, without the thread filling with placeholders. | [`enable_collaborative_conversations`]({{ '/admin/chat/' | relative_url }}) |
-| Generated (Documents drawer) | Lists the documents agents created in this conversation with the SimpleChat upload actions. Markdown opens in a preview, and Download appears only when the workspace's download rules allow it for you. | Use it to open or save a briefing or report an agent produced without hunting for it in a workspace. | [`allow_group_workspace_file_downloads`]({{ '/admin/workspaces/' | relative_url }}) for group documents<br>[`allow_personal_workspace_file_downloads`]({{ '/admin/workspaces/' | relative_url }}) for personal documents |
+
+## Documents drawer (V2 interface)
+
+These controls exist only in the V2 interface, so they are not part of the generated inventory above, which is taken from the classic chat page. The drawer's **Documents** tab gathers what a conversation used and what it produced, in personal and shared conversations alike, so a file or source is not lost in a long thread. See [Documents drawer generated files fix]({{ '/explanation/fixes/DOCUMENTS_DRAWER_GENERATED_FILES_FIX/' | relative_url }}) for how generated files are found.
+
+| Control | What it does | Why you would use it | Enabled by |
+| --- | --- | --- | --- |
+| Documents button badge | Counts the documents answers used plus every file and document the conversation produced, each once. Media is not counted. | Use it to see at a glance that a reply produced a file, even with the drawer closed. | Always available |
+| Generated (Documents drawer) | Lists every file the conversation produced, in conversation order. That covers the files an orchestration plan rendered (CSV, Excel, Word, PDF, PowerPoint, Markdown, text, JSON, XML and YAML), exports and Analyze or comparison files a reply wrote, and documents agents created with the SimpleChat upload actions. A file that is still rendering, failed, or waits for a shared conversation owner's approval is listed with its status. **Download** appears once the file is ready, and only where the workspace's download rules allow it for an agent's document. Markdown and files that carry a preview open in place, and **Show in conversation** scrolls to the reply that produced the file. | Use it to download or reopen a file a reply made, such as a CSV export, without scrolling back through the thread to find its card. | Always available; agent documents follow [`allow_personal_workspace_file_downloads`]({{ '/admin/workspaces/' | relative_url }}) and [`allow_group_workspace_file_downloads`]({{ '/admin/workspaces/' | relative_url }}) |
 | Media (Documents drawer) | Gathers every image, video and audio clip shown in the conversation, including signed links an action fetched from a remote service, grouped as **Images**, **Videos** and **Audio** with a count for each. Images and clips open one viewer that steps through all of them, with **Show in conversation** to scroll to the message. Recordings play in place and can be downloaded. | Use it to find a photo, clip or recording again in a long thread. | Always available |
 
 ## Media in replies (V2 interface)
diff --git a/docs/reference/logging-tags.md b/docs/reference/logging-tags.md
index b321d1988..8ed08af10 100644
--- a/docs/reference/logging-tags.md
+++ b/docs/reference/logging-tags.md
@@ -87,6 +87,7 @@ Last inventoried: 2026-08-10
 - `[CONVERSATION_DELETE]`
 - `[CONVERSATION_FEED]`
 - `[CONVERSATION_FORK]`
+- `[CONVERSATION_GENERATED_DOCUMENTS]`
 - `[CONVERSATION_METADATA]`
 - `[CONVERSATION_SEARCH]`
 - `[CONVERSATION_TASK_DOCUMENTS]`
diff --git a/functional_tests/test_personal_conversation_generated_documents.py b/functional_tests/test_personal_conversation_generated_documents.py
new file mode 100644
index 000000000..116d31b9c
--- /dev/null
+++ b/functional_tests/test_personal_conversation_generated_documents.py
@@ -0,0 +1,315 @@
+#!/usr/bin/env python3
+# test_personal_conversation_generated_documents.py
+"""
+Functional test for listing and downloading documents agents created in a personal conversation.
+Version: 0.261.302
+Implemented in: 0.261.302
+
+This test ensures that the personal conversation routes behind the V2 Documents drawer's Generated
+section list the documents SimpleChat upload actions created only from messages the thread shows.
+Deleted messages, replaced thread attempts, hidden generated chat files and masked messages are
+left out, and a citation stored in compact form is rebuilt from its artifact record before it is
+read. It also checks that both routes require login and the conversation's owner before anything is
+read, and that the download route only serves a document this conversation produced, under the
+workspace's own download rules. Neither route may return exception text to the browser
+(CodeQL py/stack-trace-exposure).
+"""
+
+import ast
+import contextlib
+import importlib
+import json
+import os
+import sys
+import types
+
+sys.path.append(os.path.dirname(os.path.abspath(__file__)))
+
+from test_support.versioning import assert_app_version_at_least
+
+ROOT_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+APP_DIR = os.path.join(ROOT_DIR, "application", "single_app")
+ROUTE_FILE = os.path.join(APP_DIR, "route_backend_conversations.py")
+IMPLEMENTED_IN_VERSION = "0.261.302"
+CONVERSATION_ID = "conv-personal-1"
+DOC_WORD = "11111111-2222-3333-4444-555555555555"
+DOC_DECK = "22222222-3333-4444-5555-666666666666"
+DOC_DELETED = "33333333-4444-5555-6666-777777777777"
+DOC_OLD_ATTEMPT = "44444444-5555-6666-7777-888888888888"
+DOC_MASKED = "55555555-6666-7777-8888-999999999999"
+DOC_HIDDEN_FILE = "66666666-7777-8888-9999-000000000000"
+LIST_ROUTE = "list_personal_conversation_generated_documents_api"
+DOWNLOAD_ROUTE = "download_personal_conversation_generated_document_api"
+HELPER = "_list_personal_conversation_generated_documents"
+SAFE_EXCEPTION_ATTRIBUTES = {"public_message", "code", "status_code"}
+
+
+def route_module_ast():
+    with open(ROUTE_FILE, "r", encoding="utf-8") as handle:
+        return ast.parse(handle.read())
+
+
+def functions_named(*names):
+    found = {
+        node.name: node for node in ast.walk(route_module_ast())
+        if isinstance(node, ast.FunctionDef) and node.name in names
+    }
+    assert set(found) == set(names), sorted(found)
+    return found
+
+
+@contextlib.contextmanager
+def real_helper_modules():
+    """Import the real message and generated-document helpers, faking only their heavy dependencies."""
+    names = [
+        "config",
+        "functions_azure_maps",
+        "functions_documents",
+        "functions_group",
+        "functions_settings",
+        "functions_message_artifacts",
+        "functions_message_deletion",
+        "functions_collaboration_generated_documents",
+    ]
+    saved = {name: sys.modules.get(name) for name in names}
+    sys.path.insert(0, APP_DIR)
+    try:
+        azure_maps = types.ModuleType("functions_azure_maps")
+        azure_maps.refresh_azure_maps_citation_payload = lambda payload: payload
+        documents = types.ModuleType("functions_documents")
+        documents.get_document_record = lambda **_kwargs: None
+        group = types.ModuleType("functions_group")
+        group.assert_group_role = lambda *_args, **_kwargs: "Owner"
+        group.find_group_by_id = lambda _group_id: None
+        settings = types.ModuleType("functions_settings")
+        settings.get_settings = lambda: {}
+        settings.is_group_workspace_file_download_enabled = lambda _settings, _group: False
+        settings.is_personal_workspace_file_download_enabled = lambda _settings: False
+        sys.modules.update({
+            "functions_azure_maps": azure_maps,
+            "functions_documents": documents,
+            "functions_group": group,
+            "functions_settings": settings,
+        })
+        for name in ("functions_message_artifacts", "functions_message_deletion",
+                     "functions_collaboration_generated_documents"):
+            sys.modules.pop(name, None)
+        yield (
+            importlib.import_module("functions_message_artifacts"),
+            importlib.import_module("functions_message_deletion"),
+            importlib.import_module("functions_collaboration_generated_documents"),
+        )
+    finally:
+        sys.path.remove(APP_DIR)
+        for name, module in saved.items():
+            if module is None:
+                sys.modules.pop(name, None)
+            else:
+                sys.modules[name] = module
+
+
+class FakeMessagesContainer:
+    """The conversation's messages, with the queries the helper made."""
+
+    def __init__(self, items):
+        self.items = items
+        self.queries = []
+
+    def query_items(self, query, parameters=None, partition_key=None, **_kwargs):
+        self.queries.append({"query": query, "parameters": parameters, "partition_key": partition_key})
+        return list(self.items)
+
+
+def upload_citation(document_id, file_name, function_name="upload_word_document", **extra):
+    return {
+        "plugin_name": "SimpleChatPlugin",
+        "function_name": function_name,
+        "timestamp": "2026-10-08T12:00:00Z",
+        "function_result": {
+            "success": True,
+            "document": {"id": document_id, "file_name": file_name},
+            "workspace_scope": "personal",
+        },
+        **extra,
+    }
+
+
+def assistant(message_id, timestamp, citations, **metadata):
+    return {
+        "id": message_id,
+        "conversation_id": CONVERSATION_ID,
+        "role": "assistant",
+        "timestamp": timestamp,
+        "content": "Done.",
+        "agent_citations": citations,
+        "metadata": {"thread_info": {"active_thread": True}, **metadata},
+    }
+
+
+def build_helper(container, log):
+    """The real helper's source, run against the fake container and the real collaborators."""
+    helper = functions_named(HELPER)[HELPER]
+    module = ast.Module(body=[helper], type_ignores=[])
+    namespace = {}
+    with real_helper_modules() as (artifacts, deletion, generated):
+        namespace.update({
+            "cosmos_messages_container": container,
+            "exclude_soft_deleted_messages": deletion.exclude_soft_deleted_messages,
+            "build_message_artifact_payload_map": artifacts.build_message_artifact_payload_map,
+            "filter_assistant_artifact_items": artifacts.filter_assistant_artifact_items,
+            "hydrate_agent_citations_from_artifacts": artifacts.hydrate_agent_citations_from_artifacts,
+            "collect_generated_documents": generated.collect_generated_documents,
+            "log_event": lambda message, **kwargs: log.append((message, kwargs)),
+        })
+        exec(compile(module, ROUTE_FILE, "exec"), namespace)
+    return namespace[HELPER]
+
+
+def test_only_documents_the_thread_shows_are_listed():
+    print("Testing which messages the personal list reads...")
+    deck = upload_citation(DOC_DECK, "Quarterly review.pptx", "upload_powerpoint_document")
+    compact = {
+        "tool_name": "upload_powerpoint_document",
+        "function_name": "upload_powerpoint_document",
+        "plugin_name": "SimpleChatPlugin",
+        "function_result": {"success": True, "document": "{…}"},
+        "artifact_id": "artifact-deck",
+        "raw_payload_externalized": True,
+    }
+    items = [
+        {"id": "u-1", "conversation_id": CONVERSATION_ID, "role": "user", "timestamp": "2026-10-08T11:59:00Z",
+         "content": "Write the brief and the deck.", "metadata": {}},
+        # Stored out of order on purpose: the list follows the conversation, not storage order.
+        assistant("a-2", "2026-10-08T12:02:00Z", [compact]),
+        assistant("a-1", "2026-10-08T12:01:00Z", [upload_citation(DOC_WORD, "Watch brief.docx")]),
+        {"id": "artifact-deck", "conversation_id": CONVERSATION_ID, "role": "assistant_artifact",
+         "content": json.dumps({"citation": deck}), "metadata": {}},
+        assistant("a-deleted", "2026-10-08T12:03:00Z", [upload_citation(DOC_DELETED, "Deleted.docx")], is_deleted=True),
+        assistant("a-old", "2026-10-08T12:04:00Z", [upload_citation(DOC_OLD_ATTEMPT, "Old attempt.docx")],
+                  thread_info={"active_thread": False}),
+        assistant("a-masked", "2026-10-08T12:05:00Z", [upload_citation(DOC_MASKED, "Masked.md", "upload_markdown_document")],
+                  masked=True),
+        {**assistant("f-hidden", "2026-10-08T12:06:00Z", [upload_citation(DOC_HIDDEN_FILE, "Hidden.docx")],
+                     is_generated_chat_artifact=True), "role": "file"},
+        assistant("a-legacy", "2026-10-08T12:07:00Z", [upload_citation(DOC_WORD, "Watch brief.docx")],
+                  thread_info=None),
+    ]
+    container = FakeMessagesContainer(items)
+    log = []
+    listed = build_helper(container, log)({"id": CONVERSATION_ID, "user_id": "u-owner"})
+
+    assert [entry["document_id"] for entry in listed] == [DOC_WORD, DOC_DECK], listed
+    assert listed[0]["message_id"] == "a-1" and listed[0]["file_name"] == "Watch brief.docx"
+    assert listed[1]["file_name"] == "Quarterly review.pptx", "a compact citation is rebuilt from its artifact record"
+    assert all(entry["workspace_scope"] == "personal" for entry in listed)
+
+    assert len(container.queries) == 1, container.queries
+    query = container.queries[0]
+    assert query["partition_key"] == CONVERSATION_ID, "only the authorized conversation's partition is read"
+    assert query["parameters"] == [{"name": "@conversation_id", "value": CONVERSATION_ID}], query
+    assert "@conversation_id" in query["query"] and CONVERSATION_ID not in query["query"], "the id is a parameter"
+    assert log and log[0][1].get("debug_only") is True, "the listing is debug-logged only"
+    print("  ok  deleted, replaced, masked and hidden messages are skipped; compact citations are rebuilt")
+
+
+def test_routes_require_the_owner_before_reading():
+    print("Testing the personal routes' access policy...")
+    functions = functions_named(LIST_ROUTE, DOWNLOAD_ROUTE)
+    expected_paths = {
+        LIST_ROUTE: "/api/conversations/<conversation_id>/generated-documents",
+        DOWNLOAD_ROUTE: "/api/conversations/<conversation_id>/generated-documents/<document_id>/download",
+    }
+    for name, node in functions.items():
+        decorators = [ast.unparse(decorator) for decorator in node.decorator_list]
+        assert decorators[0].startswith("bp.route("), (name, decorators)
+        assert f"'{expected_paths[name]}'" in decorators[0] and "methods=['GET']" in decorators[0], decorators[0]
+        assert decorators[1:] == ["swagger_route(security=get_auth_security())", "login_required", "user_required"], (
+            name, decorators,
+        )
+        calls = {
+            ast.unparse(call.func): call.lineno
+            for call in sorted(
+                (child for child in ast.walk(node) if isinstance(child, ast.Call)),
+                key=lambda child: child.lineno,
+                reverse=True,
+            )
+        }
+        assert "get_current_user_id" in calls, name
+        authorize_line = calls.get("_authorize_personal_conversation_read")
+        read_line = calls.get(HELPER)
+        assert authorize_line and read_line and authorize_line < read_line, (
+            f"{name} must confirm the caller owns the conversation before reading its messages"
+        )
+        source = ast.unparse(node)
+        assert "_authorize_personal_conversation_read(user_id, conversation_id)" in source, name
+        assert "request." not in source, f"{name} takes no identity or scope from the request"
+
+    list_source = ast.unparse(functions[LIST_ROUTE])
+    assert "'group_id'" not in list_source, "the list does not reveal group ids"
+    assert "can_download_generated_document(user_id, document, settings=settings)" in list_source
+
+    download_source = ast.unparse(functions[DOWNLOAD_ROUTE])
+    assert "candidate['document_id'] == document_id" in download_source, "only this conversation's documents are served"
+    assert "authorize_generated_document_download(user_id, document)" in download_source
+    assert "build_document_download_response(" in download_source
+
+    helper_source = ast.unparse(functions_named(HELPER)[HELPER])
+    assert "partition_key=conversation_id" in helper_source
+    assert "conversation_item['id']" in helper_source, "the helper reads the authorized conversation's id"
+    print("  ok  login, owner check first, scoped to the conversation's own documents")
+
+
+def test_routes_never_return_exception_text():
+    print("Testing that refusals and failures keep exception details in the server log...")
+    for name, node in functions_named(LIST_ROUTE, DOWNLOAD_ROUTE).items():
+        parents = {}
+        for parent in ast.walk(node):
+            for child in ast.iter_child_nodes(parent):
+                parents[child] = parent
+        caught = {
+            handler.name for handler in ast.walk(node)
+            if isinstance(handler, ast.ExceptHandler) and handler.name
+        }
+        assert caught, name
+        responses = [
+            call for call in ast.walk(node)
+            if isinstance(call, ast.Call) and isinstance(call.func, ast.Name) and call.func.id == "jsonify"
+        ]
+        assert responses, name
+        for call in responses:
+            for child in ast.walk(call):
+                if isinstance(child, ast.Name) and child.id in caught:
+                    parent = parents.get(child)
+                    # Only a screening error's own public sentence and code may reach the browser.
+                    assert isinstance(parent, ast.Attribute) and parent.attr in SAFE_EXCEPTION_ATTRIBUTES, (
+                        name, ast.unparse(call),
+                    )
+            assert "format_exc" not in ast.unparse(call), (name, ast.unparse(call))
+        source = ast.unparse(node)
+        for exposed in ("str(exc)", "str(e)", "repr(exc)", "str(error)"):
+            assert exposed not in source, (name, exposed)
+    print("  ok  every error response is a fixed message")
+
+
+def test_client_reads_the_same_routes():
+    print("Testing that the V2 client reads the personal routes...")
+    client_file = os.path.join(ROOT_DIR, "application", "v2_ui", "src", "lib", "generatedDocuments.ts")
+    with open(client_file, "r", encoding="utf-8") as handle:
+        client_source = handle.read()
+    assert "`/api/conversations/${encodeURIComponent(conversationId)}/generated-documents`" in client_source
+    assert "/${encodeURIComponent(documentId)}/download" in client_source
+    assert "kind === 'collaborative'" in client_source, "a shared conversation keeps its own routes"
+    print("  ok  the drawer's personal list and download use these routes")
+
+
+if __name__ == "__main__":
+    assert_app_version_at_least(IMPLEMENTED_IN_VERSION)
+    tests = [
+        test_only_documents_the_thread_shows_are_listed,
+        test_routes_require_the_owner_before_reading,
+        test_routes_never_return_exception_text,
+        test_client_reads_the_same_routes,
+    ]
+    for test in tests:
+        test()
+    print(f"\n{len(tests)} personal generated document checks passed")
diff --git a/functional_tests/test_v2_drawer_generated_files_logic.mjs b/functional_tests/test_v2_drawer_generated_files_logic.mjs
new file mode 100644
index 000000000..7b99a6953
--- /dev/null
+++ b/functional_tests/test_v2_drawer_generated_files_logic.mjs
@@ -0,0 +1,327 @@
+// test_v2_drawer_generated_files_logic.mjs
+// Version: 0.261.302
+// Implemented in: 0.261.302
+// Executes the real V2 helpers behind the Generated section of the conversation drawer: every
+// file a reply produced is listed for any conversation, not only shared ones. That covers each
+// format an orchestration plan can render, the screenshot case of a finished CSV, legacy
+// tabular, Analyze and background exports, and approval-withheld files. Each file carries its
+// status, and the live run state takes precedence. The section hides what the thread hides,
+// lists each file once in conversation order, gates the agent-document request and re-reads it
+// whenever the replies the thread shows change, lists only agent documents whose reply is shown,
+// and counts the header badge without double counting.
+
+import assert from 'node:assert/strict';
+import './test_support/tsResolve.mjs';
+
+const hadWindow = 'window' in globalThis;
+const previousWindow = globalThis.window;
+const originalFetch = globalThis.fetch;
+globalThis.window = { location: { href: 'https://chat.example.gov/v2/chat' } };
+globalThis.fetch = () => {
+    throw new Error('The generated-files helpers must not make network requests.');
+};
+
+try {
+    const {
+        collectConversationGeneratedFiles,
+        countConversationDocuments,
+        generatedDocumentsThreadKey,
+        generatedFileDetails,
+        mayHaveGeneratedDocuments,
+        mergeGeneratedEntries,
+        messageGeneratedFiles,
+        visibleGeneratedDocuments,
+    } = await import('../application/v2_ui/src/lib/conversationGeneratedFiles.ts');
+    const { artifactDownloadPath, normalizeGeneratedArtifact } = await import(
+        '../application/v2_ui/src/lib/generatedArtifacts.ts'
+    );
+
+    const CONVERSATION = 'conv-1';
+
+    function reply(id, metadata = {}, extra = {}) {
+        return { id, conversation_id: CONVERSATION, role: 'assistant', content: 'Done.', metadata, ...extra };
+    }
+
+    function output(id, format, state, extra = {}) {
+        return {
+            output_id: id, step_id: `step-${id}`, file_name: `${id}.${format}`, output_format: format,
+            profile: 'prepared_text_v1', state, attempt_count: 1, automatic_attempts: 1, max_automatic_attempts: 3,
+            next_retry_at: null, can_retry: false, available: true, error_code: null, message: '',
+            artifact_message_id: state === 'completed' ? `art-${id}` : null,
+            row_count: null, character_count: null, size_bytes: null, ...extra,
+        };
+    }
+
+    function receipt(out, extra = {}) {
+        return {
+            capability: 'render_file', source_kind: 'orchestration_retained_output', output_id: out.output_id,
+            artifact_message_id: out.artifact_message_id, conversation_id: CONVERSATION, storage_scope: 'chat',
+            file_name: out.file_name, output_format: out.output_format, profile: out.profile, ...extra,
+        };
+    }
+
+    function planReply(id, runId, outputs, receipts = outputs.filter((o) => o.state === 'completed').map((o) => receipt(o))) {
+        return reply(id, { orchestration: { run_id: runId, outputs } }, { generated_artifacts: receipts });
+    }
+
+    // The screenshot: a plan wrote a CSV, its card says Completed, and the drawer listed nothing.
+    const csv = output('us_states_and_capitals', 'csv', 'completed', {
+        file_name: 'us_states_and_capitals.csv', profile: 'tabular_records_v1', row_count: 50, size_bytes: 1006,
+    });
+    const [screenshot] = messageGeneratedFiles(planReply('a-csv', 'run-csv', [csv]));
+    assert.equal(screenshot.fileName, 'us_states_and_capitals.csv');
+    assert.equal(screenshot.status, 'ready');
+    assert.equal(screenshot.typeLabel, 'CSV file');
+    assert.equal(generatedFileDetails(screenshot), 'CSV file · 50 rows · 1006 B');
+    assert.equal(screenshot.messageId, 'a-csv', 'Show in conversation goes to the reply that made it');
+    assert.equal(
+        artifactDownloadPath(screenshot.artifact, CONVERSATION),
+        '/api/chat_artifacts/download?conversation_id=conv-1&message_id=art-us_states_and_capitals',
+        'downloads go through the authorized chat artifact route',
+    );
+
+    // Every format a plan can render is listed, with the label a person uses for it.
+    const labels = {
+        csv: 'CSV file', json: 'JSON file', xml: 'XML file', yaml: 'YAML file', md: 'Markdown file',
+        txt: 'Text file', xlsx: 'Excel workbook', docx: 'Word document', pdf: 'PDF document', pptx: 'PowerPoint deck',
+    };
+    const everyFormat = Object.keys(labels).map((format) => output(`file-${format}`, format, 'completed'));
+    const rendered = messageGeneratedFiles(planReply('a-formats', 'run-formats', everyFormat));
+    assert.deepEqual(rendered.map((file) => [file.format, file.typeLabel, file.status]),
+        Object.entries(labels).map(([format, label]) => [format, label, 'ready']));
+    assert.ok(rendered.every((file) => file.artifact), 'every ready file can be downloaded');
+
+    // Files that are not ready are listed with their status and nothing to download.
+    const states = messageGeneratedFiles(planReply('a-states', 'run-states', [
+        output('waiting', 'pdf', 'waiting'),
+        output('rendering', 'docx', 'rendering'),
+        output('retrying', 'pptx', 'retry_scheduled'),
+        output('failed', 'xlsx', 'failed'),
+        output('stopped', 'md', 'cancelled'),
+        output('no-receipt', 'csv', 'completed'),
+        output('revoked', 'csv', 'completed', { available: false }),
+        output('unknown', 'txt', 'mystery'),
+    ], []));
+    assert.deepEqual(states.map((file) => [file.fileName, file.status, file.statusLabel]), [
+        ['waiting.pdf', 'pending', 'Waiting'],
+        ['rendering.docx', 'pending', 'Rendering'],
+        ['retrying.pptx', 'pending', 'Automatic retry scheduled'],
+        ['failed.xlsx', 'failed', 'Failed'],
+        ['stopped.md', 'cancelled', 'Cancelled'],
+        ['no-receipt.csv', 'unavailable', 'Download details unavailable'],
+        ['revoked.csv', 'unavailable', 'Unavailable'],
+        ['unknown.txt', 'unavailable', 'Status unavailable'],
+    ]);
+    assert.ok(states.every((file) => file.artifact === null), 'only a ready file offers a download');
+
+    // The live run state the file cards poll takes precedence over the snapshot saved on the reply.
+    const pending = output('report', 'pdf', 'rendering');
+    const finished = output('report', 'pdf', 'completed', { size_bytes: 2048 });
+    const liveReply = planReply('a-live', 'run-live', [pending], []);
+    assert.equal(messageGeneratedFiles(liveReply)[0].status, 'pending');
+    const live = messageGeneratedFiles(liveReply, {
+        runs: { 'run-live': { outputs: [finished], generated_artifacts: [normalizeGeneratedArtifact(receipt(finished))] } },
+    });
+    assert.deepEqual([live[0].status, generatedFileDetails(live[0])], ['ready', 'PDF document · 2 KB']);
+    const denied = messageGeneratedFiles(liveReply, { runs: { 'run-live': { outputs: [finished], outputAccessDenied: true } } });
+    assert.deepEqual([denied[0].status, denied[0].artifact], ['unavailable', null], 'withheld when access cannot be confirmed');
+
+    // Exports and analysis files written by ordinary replies are listed too.
+    const exports = messageGeneratedFiles(reply('a-exports', {
+        generated_tabular_outputs: [{
+            capability: 'tabular', artifact_message_id: 'tab-1', conversation_id: CONVERSATION,
+            file_name: 'orders.csv', output_format: 'csv', row_count: 1200,
+        }],
+        generated_analysis_artifacts: [{
+            capability: 'analyze', artifact_message_id: 'an-1', conversation_id: CONVERSATION,
+            file_name: 'summary.md', output_format: 'markdown', preview_text: '# Summary',
+        }],
+    }));
+    assert.deepEqual(exports.map((file) => [file.fileName, file.typeLabel, file.status]), [
+        ['summary.md', 'Markdown file', 'ready'],
+        ['orders.csv', 'CSV file', 'ready'],
+    ]);
+    assert.equal(generatedFileDetails(exports[1]), `CSV file · ${(1200).toLocaleString()} rows`);
+
+    // A workspace copy keeps its document id, so the badge does not count it twice.
+    const [workspaceCopy] = messageGeneratedFiles(reply('a-ws', {
+        generated_tabular_outputs: [{ capability: 'tabular', document_id: 'doc-9', file_name: 'saved.xlsx', output_format: 'xlsx' }],
+    }));
+    assert.deepEqual([workspaceCopy.documentId, workspaceCopy.status, workspaceCopy.key], ['doc-9', 'ready', 'document:doc-9']);
+
+    // A background export is generating until its card reports the files it produced.
+    const background = reply('a-bg', {
+        generated_tabular_outputs: [{
+            capability: 'tabular', export_run_id: 'exp-1', background_export: true, output_format: 'xlsx', status: 'running',
+        }],
+    });
+    const [generating] = messageGeneratedFiles(background);
+    assert.deepEqual([generating.fileName, generating.status, generating.statusLabel], ['Generated XLSX export', 'pending', 'Generating']);
+    const member = normalizeGeneratedArtifact({
+        capability: 'tabular', artifact_message_id: 'tab-done', conversation_id: CONVERSATION,
+        file_name: 'large-export.xlsx', output_format: 'xlsx', row_count: 90000,
+    });
+    const done = messageGeneratedFiles(background, { exportRuns: { 'exp-1': { status: 'completed', members: [member] } } });
+    assert.deepEqual(done.map((file) => [file.fileName, file.status]), [['large-export.xlsx', 'ready']]);
+    assert.equal(messageGeneratedFiles(background, { exportRuns: { 'exp-1': { status: 'failed' } } })[0].status, 'failed');
+    assert.equal(
+        messageGeneratedFiles(background, { exportRuns: { 'exp-1': { status: 'failed', retryableFailure: true } } })[0].status,
+        'pending', 'a failure the worker will retry is still in progress',
+    );
+    const [stopped] = messageGeneratedFiles(reply('a-stopped', {
+        generated_tabular_outputs: [{
+            capability: 'tabular', export_run_id: 'exp-2', status: 'canceled', suppress_assistant_table_export: true,
+        }],
+    }));
+    assert.equal(stopped.status, 'cancelled');
+
+    // A file staged for the conversation owner's approval is listed but not downloadable.
+    const staged = (state) => messageGeneratedFiles(reply(`a-${state}`, {
+        generated_tabular_outputs: [{
+            capability: 'tabular', artifact_message_id: `staged-${state}`, conversation_id: CONVERSATION,
+            file_name: 'shared.csv', output_format: 'csv', approval: { state },
+        }],
+    }))[0];
+    assert.deepEqual(['pending_approval', 'denied', 'auto_denied', 'approved'].map((state) => [staged(state).status, staged(state).statusLabel]), [
+        ['withheld', 'Awaiting approval'], ['withheld', 'Declined'], ['withheld', 'Expired'], ['ready', ''],
+    ]);
+
+    // What the thread hides stays hidden.
+    const exportsMetadata = {
+        generated_tabular_outputs: [{
+            capability: 'tabular', artifact_message_id: 'tab-hidden', conversation_id: CONVERSATION,
+            file_name: 'hidden.csv', output_format: 'csv',
+        }],
+    };
+    assert.deepEqual(messageGeneratedFiles(reply('a-masked', { ...exportsMetadata, masked: true })), []);
+    assert.deepEqual(messageGeneratedFiles(reply('a-superseded', { ...exportsMetadata, superseded_by_workflow_reply: true })), []);
+    assert.deepEqual(messageGeneratedFiles({ ...reply('u-1', exportsMetadata), role: 'user' }), []);
+    const partlyMasked = planReply('a-partial', 'run-partial', [csv]);
+    partlyMasked.metadata = { ...partlyMasked.metadata, ...exportsMetadata, masked_ranges: [{ start: 0, end: 2 }] };
+    assert.deepEqual(messageGeneratedFiles(partlyMasked).map((file) => file.fileName), ['hidden.csv'],
+        'a partly masked reply hides its plan files, as the thread does, and keeps its other files');
+
+    // Saved Analyze findings gate their downloads exactly as the thread gates them.
+    const savedAnalysis = {
+        version: 'analyze-final-v1', conversation_id: CONVERSATION, message_id: 'a-analysis',
+        result_sha256: 'a'.repeat(64), record_count: 3, source_count: 1, validation_status: 'valid',
+    };
+    assert.equal(messageGeneratedFiles(reply('a-analysis', { ...exportsMetadata, saved_analysis: savedAnalysis })).length, 1);
+    assert.equal(messageGeneratedFiles(reply('a-analysis', { ...exportsMetadata, saved_analysis: { ...savedAnalysis, available: false } })).length, 0);
+    assert.equal(messageGeneratedFiles(reply('a-analysis', { ...exportsMetadata, saved_analysis: { broken: true } })).length, 0);
+
+    // A plan's committed file is listed once, under its file card, not again as a loose receipt.
+    assert.equal(messageGeneratedFiles(planReply('a-once', 'run-once', [csv])).length, 1);
+    const receiptOnly = reply('a-receipt', { orchestration: { run_id: 'run-receipt' } }, { generated_artifacts: [receipt(csv)] });
+    assert.deepEqual(messageGeneratedFiles(receiptOnly).map((file) => [file.fileName, file.status]),
+        [['us_states_and_capitals.csv', 'ready']], 'without file cards the receipt itself is listed');
+
+    // Each file once, oldest first, attributed to the first reply that showed it.
+    const retry = planReply('a-retry', 'run-retry', [csv]);
+    const conversation = [
+        { id: 'u-0', conversation_id: CONVERSATION, role: 'user', content: 'Make a CSV' },
+        planReply('a-csv', 'run-csv', [csv]),
+        reply('a-exports', {
+            generated_tabular_outputs: [{
+                capability: 'tabular', artifact_message_id: 'tab-1', conversation_id: CONVERSATION,
+                file_name: 'orders.csv', output_format: 'csv',
+            }],
+        }),
+        retry,
+    ];
+    const all = collectConversationGeneratedFiles(conversation);
+    assert.deepEqual(all.map((file) => [file.fileName, file.messageId]), [
+        ['us_states_and_capitals.csv', 'a-csv'],
+        ['orders.csv', 'a-exports'],
+    ]);
+
+    // The agent-document request is made only when the thread can hold such a document.
+    const upload = { function_name: 'upload_word_document', function_result: '{}' };
+    assert.equal(mayHaveGeneratedDocuments([reply('a-1', {}, { agent_citations: [upload] })]), true);
+    assert.equal(mayHaveGeneratedDocuments([reply('a-1', {}, { agent_citations: [{ function_name: 'search_documents' }] })]), false);
+    assert.equal(mayHaveGeneratedDocuments([reply('a-1', {}, { agent_display_name: 'Analyst' })]), true,
+        "an agent's reply that finished in this tab has not had its tool calls read back yet");
+    assert.equal(mayHaveGeneratedDocuments([reply('a-1', {}, { agent_display_name: 'Analyst', agent_citations: [] })]), false);
+    assert.equal(mayHaveGeneratedDocuments([reply('a-1')]), false);
+    assert.equal(mayHaveGeneratedDocuments([{ id: 'u-1', role: 'user', content: '', agent_citations: [upload] }]), false);
+
+    // The agent-document list is read again whenever the replies the thread shows change, which a
+    // reply count misses: showing another attempt of an answer, or masking a reply, keeps the count.
+    const asked = { id: 'u-1', conversation_id: CONVERSATION, role: 'user', content: 'Write the brief' };
+    const shown = [asked, reply('a-1'), reply('a-2')];
+    const threadKey = generatedDocumentsThreadKey(shown);
+    assert.notEqual(generatedDocumentsThreadKey([asked, reply('a-1'), reply('a-2b')]), threadKey, 'another attempt shown');
+    assert.notEqual(generatedDocumentsThreadKey([asked, reply('a-1'), reply('a-2', { masked: true })]), threadKey,
+        'a reply fully masked');
+    assert.notEqual(generatedDocumentsThreadKey([...shown, reply('a-3')]), threadKey, 'a new reply');
+    assert.notEqual(generatedDocumentsThreadKey([asked, reply('a-2')]), threadKey, 'a reply deleted');
+    assert.equal(generatedDocumentsThreadKey([...shown, { ...asked, id: 'u-2' }]), threadKey,
+        "a person's own message cannot hold an agent document, so it costs no request");
+    assert.equal(generatedDocumentsThreadKey([asked, reply('a-1'), { ...reply('a-2'), content: 'Edited.' }]), threadKey);
+
+    // Only documents whose reply the thread still shows are listed and counted.
+    const agentDocument = (documentId, messageId) => ({
+        document_id: documentId, file_name: `${documentId}.docx`, workspace_scope: 'personal', preview: null,
+        message_id: messageId, created_at: '', can_download: true,
+    });
+    const listed = [
+        agentDocument('doc-shown', 'a-1'),
+        agentDocument('doc-other-attempt', 'a-2'),
+        agentDocument('doc-masked', 'a-masked'),
+        agentDocument('doc-replaced', 'a-replaced'),
+        agentDocument('doc-unattributed', ''),
+    ];
+    assert.deepEqual(visibleGeneratedDocuments(listed, [
+        asked,
+        reply('a-1'),
+        reply('a-masked', { masked: true }),
+        reply('a-replaced', { superseded_by_workflow_reply: true }),
+        reply('a-partly-masked', { masked_ranges: [{ start: 0, end: 2 }] }),
+    ]).map((document) => document.document_id), ['doc-shown']);
+    assert.deepEqual(
+        visibleGeneratedDocuments([agentDocument('doc-partial', 'a-partly-masked')], [
+            reply('a-partly-masked', { masked_ranges: [{ start: 0, end: 2 }] }),
+        ]).map((document) => document.document_id),
+        ['doc-partial'], 'masking part of a reply keeps its documents, as the server does',
+    );
+
+    // Files and agent documents share one list in conversation order; a shared document id is listed once.
+    const brief = {
+        document_id: 'doc-brief', file_name: 'Brief.docx', workspace_scope: 'personal', preview: null,
+        message_id: 'a-csv', created_at: '', can_download: true,
+    };
+    const duplicate = { ...brief, document_id: 'doc-9', message_id: 'a-ws' };
+    const entries = mergeGeneratedEntries(
+        [...collectConversationGeneratedFiles([conversation[2], reply('a-ws', {
+            generated_tabular_outputs: [{ capability: 'tabular', document_id: 'doc-9', file_name: 'saved.xlsx', output_format: 'xlsx' }],
+        })])],
+        [duplicate, brief],
+        [conversation[1], conversation[2], reply('a-ws')],
+    );
+    assert.deepEqual(entries.map((entry) => [entry.kind, entry.messageId]), [
+        ['document', 'a-csv'],
+        ['file', 'a-exports'],
+        ['file', 'a-ws'],
+    ]);
+
+    // The badge counts documents answers used and documents the conversation produced, each once.
+    const badge = countConversationDocuments(
+        {
+            used_documents: [{ document_id: 'doc-9' }, { document_id: 'doc-used' }],
+            linked_workspace_documents: [{ document_id: 'doc-used' }],
+        },
+        [screenshot, workspaceCopy],
+        [brief, { ...brief, document_id: 'doc-used' }],
+    );
+    assert.equal(badge, 4, 'doc-9, doc-used, the CSV and the brief');
+    assert.equal(countConversationDocuments(null, [], []), 0);
+
+    console.log('Drawer generated-files checks passed');
+} finally {
+    globalThis.fetch = originalFetch;
+    if (hadWindow) {
+        globalThis.window = previousWindow;
+    } else {
+        delete globalThis.window;
+    }
+}
diff --git a/ui_tests/fixtures/orchestration/harness_entry.tsx b/ui_tests/fixtures/orchestration/harness_entry.tsx
index d950e00c9..f4057bfa3 100644
--- a/ui_tests/fixtures/orchestration/harness_entry.tsx
+++ b/ui_tests/fixtures/orchestration/harness_entry.tsx
@@ -17,6 +17,8 @@ import * as orchestrationStore from '../../../application/v2_ui/src/stores/orche
 import * as chatStore from '../../../application/v2_ui/src/stores/chatStore';
 import * as bootstrapStore from '../../../application/v2_ui/src/stores/bootstrapStore';
 import * as collaborationStore from '../../../application/v2_ui/src/stores/collaborationStore';
+import * as generatedDocumentsStore from '../../../application/v2_ui/src/stores/generatedDocumentsStore';
+import * as generatedExportRunStore from '../../../application/v2_ui/src/stores/generatedExportRunStore';
 import * as userSettingsStore from '../../../application/v2_ui/src/stores/userSettingsStore';
 import * as assistThreadStore from '../../../application/v2_ui/src/stores/assistThreadStore';
 import * as controller from '../../../application/v2_ui/src/lib/orchestrationController';
@@ -278,6 +280,15 @@ function reset(): void {
         drawerMode: null,
         messages: [],
     });
+    // What a conversation produced is shared by the drawer and the header, so a test reusing a
+    // conversation id would otherwise start from the previous test's list.
+    generatedDocumentsStore.useGeneratedDocumentsStore.setState({
+        requestKey: null,
+        conversationId: null,
+        documents: [],
+        error: null,
+    });
+    generatedExportRunStore.useGeneratedExportRunStore.setState({ runs: {} });
     userSettingsStore.useUserSettingsStore.setState({
         settings: {},
         loading: false,
@@ -308,6 +319,8 @@ const harness = {
         chat: chatStore,
         bootstrap: bootstrapStore,
         collaboration: collaborationStore,
+        generatedDocuments: generatedDocumentsStore,
+        generatedExportRuns: generatedExportRunStore,
         userSettings: userSettingsStore,
         assistThread: assistThreadStore,
     },
diff --git a/ui_tests/test_v2_collaboration_ux.py b/ui_tests/test_v2_collaboration_ux.py
index 6cbfe07b5..a2e53d827 100644
--- a/ui_tests/test_v2_collaboration_ux.py
+++ b/ui_tests/test_v2_collaboration_ux.py
@@ -1,17 +1,19 @@
 # test_v2_collaboration_ux.py
 """
 UI test for the V2 shared conversation experience.
-Version: 0.261.262
+Version: 0.261.302
 Implemented in: 0.261.255
+Generated documents read only for a thread whose replies ran an upload action: 0.261.302
+Generated documents read once an invitation is joined, not refused while it is pending: 0.261.302
 
 This test ensures that, in a shared conversation, a message names the people and the agent it
 was addressed to as pills above its text instead of repeating "@Name" in it; that the composer's
 @ menu adds removable chips (any number of people, one agent, a second agent replacing the first)
 and sends them as the mentions the server stores; that running agent requests show as slim
 activity lines for everyone instead of a "Thinking" bubble; and that the conversation drawer
-lists generated documents (preview and download only where permitted) and every image and clip
-in the thread. Only HTTP boundaries are mocked; the real MessageList, Composer, ConversationDrawer
-and stores run in Chromium with production CSS.
+lists generated documents (preview and download only where permitted, and only once an invited
+reader has joined) and every image and clip in the thread. Only HTTP boundaries are mocked; the
+real MessageList, Composer, ConversationDrawer and stores run in Chromium with production CSS.
 
 Build: npm --prefix .\\application\\v2_ui run build -- --outDir ..\\..\\ui_tests\\artifacts\\orchestration-plan-editor
 Run: python -m pytest .\\ui_tests\\test_v2_collaboration_ux.py -q
@@ -73,6 +75,7 @@ def __init__(self, assets):
         self.assets = assets
         self.posts = []
         self.downloads = []
+        self.listed = []
         self.unexpected = []
         self.errors = []
 
@@ -108,6 +111,7 @@ def handle(self, route):
             route.fulfill(json={"message": stored})
             return
         if request.method == "GET" and path == f"{base}/generated-documents":
+            self.listed.append(path)
             route.fulfill(json={"documents": [
                 {"document_id": BRIEF_ID, "file_name": "Watch brief.md", "workspace_scope": "group",
                  "preview": "markdown", "message_id": "a-1", "created_at": "2026-10-02T16:12:20Z", "can_download": True},
@@ -143,7 +147,7 @@ def shared_ui(editor_browser, editor_assets):
         assert not api.errors, api.errors
 
 
-def mount(page, api, component, messages, *, chat=None, drawer=None):
+def mount(page, api, component, messages, *, chat=None, drawer=None, collaboration=None):
     page.goto(ORIGIN + HARNESS)
     page.wait_for_function("() => Boolean(window.OrchHarness)")
     for url in api.assets:
@@ -176,6 +180,7 @@ def mount(page, api, component, messages, *, chat=None, drawer=None):
                         { ...spec.me, status: 'accepted', membership_status: 'accepted' },
                         { ...spec.sam, status: 'accepted', membership_status: 'accepted' },
                     ],
+                    ...spec.collaboration,
                 },
                 replyTo: null, aiRuns: [], typingUsers: [],
             });
@@ -184,6 +189,7 @@ def mount(page, api, component, messages, *, chat=None, drawer=None):
         {
             "conversation": CONVERSATION, "me": ME, "sam": SAM, "agents": [WATCH, CELL],
             "messages": messages, "component": component, "chat": chat or {}, "drawer": drawer,
+            "collaboration": collaboration or {},
         },
     )
 
@@ -304,20 +310,33 @@ def test_composer_mentions_become_chips_and_are_sent_as_mentions(shared_ui):
     expect(page.get_by_role("list", name="Sending to")).to_have_count(0)
 
 
-def test_drawer_lists_generated_documents_and_media(shared_ui):
-    page, api = shared_ui
-    reply = message("a-1", "assistant", "\n".join([
+def brief_reply():
+    """An agent's reply that created two documents and shows a capture and a clip."""
+    return message("a-1", "assistant", "\n".join([
         "The brief is ready.",
         f"![Plate capture at the bridge]({CAPTURE})",
         f"[Open video: Bridge camera clip]({CLIP})",
-    ]))
-    mount(page, api, "ConversationDrawer", [reply], drawer="documents")
+    ]), agent_citations=[
+        # The upload actions' results are what the server lists the generated documents from.
+        {"function_name": "upload_markdown_document", "plugin_name": "SimpleChatPlugin",
+         "function_result": {"success": True, "workspace_scope": "group", "group_id": "group-1",
+                             "document": {"id": BRIEF_ID, "file_name": "Watch brief.md"}}},
+        {"function_name": "upload_word_document", "plugin_name": "SimpleChatPlugin",
+         "function_result": {"success": True, "workspace_scope": "personal",
+                             "document": {"id": WORD_ID, "file_name": "Quarterly brief.docx"}}},
+    ])
+
+
+def test_drawer_lists_generated_documents_and_media(shared_ui):
+    page, api = shared_ui
+    mount(page, api, "ConversationDrawer", [brief_reply()], drawer="documents")
 
     generated = page.get_by_role("region", name="Generated documents")
     expect(generated.locator("[data-generated-document]")).to_have_count(2)
     word = generated.locator(f"[data-generated-document='{WORD_ID}']")
     expect(word).to_contain_text("Download not permitted")
-    expect(word.get_by_role("button")).to_have_count(0)
+    expect(word.get_by_role("button", name=re.compile(r"^(Download|Preview) "))).to_have_count(0)
+    expect(word.get_by_role("button", name="Show Quarterly brief.docx in the conversation")).to_be_visible()
 
     generated.get_by_role("button", name="Preview Watch brief.md").click()
     dialog = page.get_by_role("dialog", name="Watch brief.md")
@@ -335,3 +354,29 @@ def test_drawer_lists_generated_documents_and_media(shared_ui):
     media.get_by_role("button", name="View image: Plate capture at the bridge").click()
     expect(page.get_by_role("dialog").filter(has_text="Plate capture at the bridge")).to_be_visible()
     assert api.downloads == [BRIEF_ID, BRIEF_ID], api.downloads
+
+
+def test_an_invitation_lists_generated_documents_once_it_is_joined(shared_ui):
+    page, api = shared_ui
+    # An invited reader can read the thread, but the server refuses its document list until they join.
+    mount(page, api, "ConversationDrawer", [brief_reply()], drawer="documents",
+          collaboration={"can_accept_invite": True, "membership_status": "pending"})
+    media = page.get_by_role("region", name="Media")
+    expect(media.get_by_role("button", name="View image: Plate capture at the bridge")).to_be_visible()
+    expect(page.get_by_role("region", name="Generated documents")).to_have_count(0)
+    assert api.listed == [], "no request the server would refuse"
+
+    # Joining reads the list straight away, without reopening the drawer.
+    with page.expect_request(lambda request: urlsplit(request.url).path.endswith("/generated-documents")):
+        page.evaluate(
+            """() => {
+                const store = window.OrchHarness.stores.collaboration.useCollaborationStore;
+                const conversation = store.getState().conversation;
+                store.setState({ conversation: {
+                    ...conversation, can_accept_invite: false, membership_status: 'accepted',
+                } });
+            }"""
+        )
+    generated = page.get_by_role("region", name="Generated documents")
+    expect(generated.locator("[data-generated-document]")).to_have_count(2)
+    assert len(api.listed) == 1, api.listed
diff --git a/ui_tests/test_v2_drawer_generated_files.py b/ui_tests/test_v2_drawer_generated_files.py
new file mode 100644
index 000000000..f343ec4ec
--- /dev/null
+++ b/ui_tests/test_v2_drawer_generated_files.py
@@ -0,0 +1,491 @@
+# test_v2_drawer_generated_files.py
+"""
+UI test for the V2 Documents drawer listing every file a conversation produced.
+Version: 0.261.302
+Implemented in: 0.261.302
+
+This test ensures that the Documents tab of the conversation drawer, in a personal conversation,
+lists every file the replies produced. That includes the CSV an orchestration plan rendered (the
+reported case), files that are still rendering or failed, and an Analyze summary, alongside a Word
+document an agent created with a SimpleChat upload action, all in conversation order. Ready files
+download through their authorized routes; a file that is not ready shows its status and offers no
+download. A Markdown summary opens in a preview, and Show in conversation scrolls to the reply that
+produced the file. A background export that finishes while the conversation is open becomes
+downloadable in the drawer. Agent documents follow the thread: showing another attempt of an
+answer or masking a reply re-reads them and hides what the thread no longer shows, and a refused
+list is asked again when the drawer reopens. A conversation that produced nothing still says so,
+and the chat header's Documents badge counts generated files alongside the documents answers used.
+Only HTTP boundaries are mocked; the real ConversationDrawer, ChatPage, MessageList and stores run
+in Chromium with production CSS.
+
+Build: npm --prefix .\\application\\v2_ui run build -- --outDir ..\\..\\ui_tests\\artifacts\\orchestration-plan-editor
+Run: python -m pytest .\\ui_tests\\test_v2_drawer_generated_files.py -q
+"""
+
+import re
+from urllib.parse import parse_qs, urlsplit
+
+import pytest
+from playwright.sync_api import expect
+
+from test_v2_orchestration_plan_editor import (  # noqa: F401
+    HARNESS,
+    ORIGIN,
+    connect_options,
+    editor_assets,
+    editor_browser,
+)
+
+pytestmark = pytest.mark.ui
+
+CONVERSATION = "states-csv-chat"
+CSV_NAME = "us_states_and_capitals.csv"
+CSV_ARTIFACT = "artifact-states-csv"
+CSV_BYTES = b"State,Capital\nAlabama,Montgomery\n"
+WORD_ID = "77777777-8888-9999-aaaa-bbbbbbbbbbbb"
+WORD_NAME = "Capitals brief.docx"
+SUMMARY_NAME = "capitals-summary.md"
+GENERATED = f"/api/conversations/{CONVERSATION}/generated-documents"
+RUN_ID = "run-states"
+EXPORT_RUN = "export-run-capitals"
+EXPORT_NAME = "county-seats.csv"
+RETRY_ID = "88888888-9999-aaaa-bbbb-cccccccccccc"
+RETRY_NAME = "Capitals brief, second attempt.docx"
+
+
+def message(message_id, role, content, **extra):
+    return {
+        "id": message_id,
+        "conversation_id": CONVERSATION,
+        "role": role,
+        "content": content,
+        "timestamp": "2026-10-08T14:39:00Z",
+        "metadata": extra.pop("metadata", {}),
+        **extra,
+    }
+
+
+def output(output_id, file_name, output_format, state, **extra):
+    return {
+        "output_id": output_id, "step_id": f"render-{output_id}", "file_name": file_name,
+        "output_format": output_format, "profile": "tabular_records_v1", "state": state,
+        "attempt_count": 1, "automatic_attempts": 1, "max_automatic_attempts": 3,
+        "can_retry": False, "available": True, "message": "", **extra,
+    }
+
+
+def agent_document(document_id, file_name, message_id):
+    """One entry of the server's list of documents agents created."""
+    return {
+        "document_id": document_id, "file_name": file_name, "workspace_scope": "personal", "preview": None,
+        "message_id": message_id, "created_at": "2026-10-08T14:40:00Z", "can_download": True,
+    }
+
+
+def agent_reply(message_id, document_id, file_name, **metadata):
+    """An agent's reply whose upload action created a workspace document."""
+    return message(
+        message_id, "assistant", "I saved the brief to your workspace.",
+        agent_display_name="Report Writer",
+        agent_citations=[{
+            "plugin_name": "SimpleChatPlugin", "function_name": "upload_word_document",
+            "function_result": {"success": True, "workspace_scope": "personal",
+                                "document": {"id": document_id, "file_name": file_name}},
+        }],
+        metadata=metadata,
+    )
+
+
+PLAN_OUTPUTS = [
+    output("out-csv", CSV_NAME, "csv", "completed", artifact_message_id=CSV_ARTIFACT, row_count=50, size_bytes=1006),
+    output("out-pdf", "Capitals briefing.pdf", "pdf", "rendering"),
+    output("out-xlsx", "Capitals workbook.xlsx", "xlsx", "failed", message="The workbook could not be rendered."),
+]
+CSV_RECEIPT = {
+    "capability": "render_file", "source_kind": "orchestration_retained_output", "output_id": "out-csv",
+    "artifact_message_id": CSV_ARTIFACT, "conversation_id": CONVERSATION, "storage_scope": "chat",
+    "file_name": CSV_NAME, "output_format": "csv", "profile": "tabular_records_v1", "row_count": 50,
+}
+
+
+def conversation_messages():
+    return [
+        message("u-1", "user", "I want you to create a CSV file of all the states and their capitals."),
+        message(
+            "a-csv", "assistant", f"Files:\n\n- {CSV_NAME}: ready (50 rows, 1,006 bytes).",
+            metadata={"orchestration": {"run_id": RUN_ID, "outputs": PLAN_OUTPUTS}},
+            generated_artifacts=[CSV_RECEIPT],
+        ),
+        agent_reply("a-agent", WORD_ID, WORD_NAME),
+        message(
+            "a-summary", "assistant", "Here is a short summary.",
+            metadata={"generated_analysis_artifacts": [{
+                "capability": "analyze", "artifact_message_id": "artifact-summary", "conversation_id": CONVERSATION,
+                "storage_scope": "chat", "file_name": SUMMARY_NAME, "output_format": "md",
+                "preview_text": "# Capitals\n\nEvery state has exactly one capital city.",
+            }]},
+        ),
+    ]
+
+
+class GeneratedFilesApi:
+    """The HTTP boundary of a personal conversation, with the requests the browser made."""
+
+    def __init__(self, assets):
+        self.assets = assets
+        self.messages = conversation_messages()
+        # What the server's list of agent documents answers, and with which status.
+        self.agent_documents = [agent_document(WORD_ID, WORD_NAME, "a-agent")]
+        self.list_status = 200
+        self.requests = []
+        self.unexpected = []
+        self.errors = []
+
+    def handle(self, route):
+        request = route.request
+        parsed = urlsplit(request.url)
+        path = parsed.path
+        query = parse_qs(parsed.query)
+        if f"{parsed.scheme}://{parsed.netloc}" != ORIGIN:
+            self.unexpected.append(request.url)
+            route.abort()
+            return
+        if request.method == "GET" and path in self.assets:
+            route.fulfill(path=str(self.assets[path]))
+            return
+        if path == "/favicon.ico":
+            route.fulfill(status=204)
+            return
+        self.requests.append({"method": request.method, "path": path, "query": query})
+        if request.method == "GET" and path == GENERATED:
+            if self.list_status != 200:
+                route.fulfill(status=self.list_status, json={"error": "Conversation not found"})
+            else:
+                route.fulfill(json={"documents": self.agent_documents})
+            return
+        if request.method == "GET" and path == f"{GENERATED}/{WORD_ID}/download":
+            route.fulfill(status=200, body=b"PK\x03\x04docx", headers={
+                "Content-Type": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+                "Content-Disposition": f'attachment; filename="{WORD_NAME}"',
+            })
+            return
+        if request.method == "GET" and path == "/api/chat_artifacts/download":
+            if query.get("conversation_id") == [CONVERSATION] and query.get("message_id") == [CSV_ARTIFACT]:
+                route.fulfill(status=200, body=CSV_BYTES, headers={
+                    "Content-Type": "text/csv; charset=utf-8",
+                    "Content-Disposition": f'attachment; filename="{CSV_NAME}"',
+                })
+            else:
+                route.fulfill(status=404, json={"error": "The artifact content is unavailable."})
+            return
+        if request.method == "GET" and path == f"/api/v2/orchestration/runs/{RUN_ID}":
+            route.fulfill(json={"run": {
+                "run_id": RUN_ID, "conversation_id": CONVERSATION, "status": "running",
+                "outputs": PLAN_OUTPUTS, "generated_artifacts": [CSV_RECEIPT],
+            }})
+            return
+        if request.method == "GET" and path == f"/api/tabular/generated-output/runs/{EXPORT_RUN}":
+            route.fulfill(json={"success": True, "run": {
+                "run_id": EXPORT_RUN, "status": "completed", "background_export": True,
+                "generated_artifacts": [{
+                    "capability": "tabular", "artifact_message_id": "artifact-export", "conversation_id": CONVERSATION,
+                    "storage_scope": "chat", "file_name": EXPORT_NAME, "output_format": "csv", "row_count": 120000,
+                }],
+            }})
+            return
+        # The rest of the chat page, for the header badge test.
+        if path == "/api/get_messages":
+            route.fulfill(json={"messages": self.messages})
+            return
+        if path in ("/api/get_conversations", "/api/conversations/feed"):
+            route.fulfill(json={"conversations": [{"id": CONVERSATION, "title": "State capitals"}], "has_more": False})
+            return
+        if path == "/api/user/settings":
+            route.fulfill(json={"settings": {}})
+            return
+        if path == "/api/v2/orchestration/runs":
+            route.fulfill(json={"runs": []})
+            return
+        if path == "/api/collaboration/file-approvals":
+            route.fulfill(json={"approvals": []})
+            return
+        if path == "/api/user/collaboration-suggestions":
+            route.fulfill(json={"results": []})
+            return
+        if path == f"/api/conversations/{CONVERSATION}/metadata":
+            route.fulfill(json={
+                "conversation_id": CONVERSATION, "title": "State capitals",
+                "used_documents": [{"document_id": "doc-cited", "file_name": "Census tables.pdf"}],
+            })
+            return
+        self.unexpected.append(f"{request.method} {path}")
+        route.fulfill(status=404, json={"error": "Unmocked request"})
+
+    def calls(self, path):
+        return [request for request in self.requests if request["path"] == path]
+
+
+@pytest.fixture
+def drawer_ui(editor_browser, editor_assets):
+    context = editor_browser.new_context(viewport={"width": 1280, "height": 1000}, accept_downloads=True)
+    page = context.new_page()
+    api = GeneratedFilesApi(editor_assets)
+    page.route("**/*", api.handle)
+    page.on("pageerror", lambda error: api.errors.append(str(error)))
+    try:
+        yield page, api
+    finally:
+        context.close()
+        assert not api.unexpected, f"Unexpected browser requests: {api.unexpected}"
+        assert not api.errors, api.errors
+
+
+def mount(page, api, component, messages, *, drawer=None, entries=None, used_documents=()):
+    page.goto(ORIGIN + HARNESS)
+    page.wait_for_function("() => Boolean(window.OrchHarness)")
+    for url in api.assets:
+        if url.endswith(".css"):
+            page.add_style_tag(url=ORIGIN + url)
+    page.evaluate(
+        """(spec) => {
+            const H = window.OrchHarness;
+            H.reset();
+            H.stores.bootstrap.useBootstrapStore.setState({ data: {
+                version: '0.261.302', settings: {}, branding: { app_title: 'SimpleChat' },
+                features: {},
+                user: { id: 'ui-user', display_name: 'Pat Reader' },
+                scope: { groups: [], public_workspaces: [] },
+                catalogs: { models: [], agents: [], prompts: [] },
+            } });
+            // Seeded as an opened conversation has it: its messages and its metadata are loaded.
+            H.stores.chat.useChatStore.setState({
+                activeConversationId: spec.conversation, activeConversationKind: 'personal',
+                conversations: [{ id: spec.conversation, title: 'State capitals' }],
+                messagesLoading: false, messagesError: null, streaming: false, streamingContent: '',
+                streamError: null, thoughts: [], messages: spec.messages,
+                drawerMode: spec.drawer,
+                metadata: {
+                    conversation_id: spec.conversation, title: 'State capitals',
+                    used_documents: spec.usedDocuments,
+                },
+            });
+            H.mount(spec.entries ? 'mount-a' : 'test-root', spec.component, {},
+                spec.entries ? { initialEntries: spec.entries } : {});
+        }""",
+        {
+            "conversation": CONVERSATION, "messages": messages, "component": component,
+            "drawer": drawer, "entries": entries, "usedDocuments": list(used_documents),
+        },
+    )
+
+
+def generated_region(page):
+    return page.get_by_role("region", name="Generated documents")
+
+
+def is_generated_list(request):
+    return urlsplit(request.url).path == GENERATED
+
+
+def set_messages(page, messages):
+    """Replace the thread, as reading it again after an attempt switch or a mask does."""
+    page.evaluate("(messages) => window.OrchHarness.stores.chat.useChatStore.setState({ messages })", messages)
+
+
+def set_drawer(page, mode):
+    page.evaluate("(mode) => window.OrchHarness.stores.chat.useChatStore.getState().setDrawerMode(mode)", mode)
+
+
+def test_drawer_lists_every_generated_file_in_conversation_order(drawer_ui):
+    page, api = drawer_ui
+    mount(page, api, "ConversationDrawer", conversation_messages(), drawer="documents")
+
+    generated = generated_region(page)
+    expect(generated.get_by_role("heading", name="Generated")).to_be_visible()
+    rows = generated.locator("li")
+    expect(rows).to_have_count(5)
+    expect(rows.nth(0)).to_contain_text(CSV_NAME)
+    expect(rows.nth(1)).to_contain_text("Capitals briefing.pdf")
+    expect(rows.nth(2)).to_contain_text("Capitals workbook.xlsx")
+    expect(rows.nth(3)).to_contain_text(WORD_NAME)
+    expect(rows.nth(4)).to_contain_text(SUMMARY_NAME)
+    assert len(api.calls(GENERATED)) == 1, "the agent-document list is read once"
+
+    # The reported case: a plan's CSV is listed as the thread's card describes it, and downloads.
+    csv = generated.locator(f"[data-generated-file='artifact:{CSV_ARTIFACT}']")
+    expect(csv).to_contain_text("CSV file · 50 rows · 1006 B")
+    expect(csv).to_have_attribute("data-generated-file-status", "ready")
+    with page.expect_download() as download_info:
+        csv.get_by_role("button", name=f"Download {CSV_NAME}").click()
+    assert download_info.value.suggested_filename == CSV_NAME
+    downloads = api.calls("/api/chat_artifacts/download")
+    assert [call["query"].get("message_id") for call in downloads] == [[CSV_ARTIFACT]], downloads
+
+    # Files that are not ready say where they stand and offer nothing to download.
+    for name, status, label in (
+        ("Capitals briefing.pdf", "pending", "Rendering"),
+        ("Capitals workbook.xlsx", "failed", "Failed"),
+    ):
+        row = generated.locator("[data-generated-file]").filter(has_text=name)
+        expect(row).to_have_attribute("data-generated-file-status", status)
+        expect(row).to_contain_text(label)
+        expect(row.get_by_role("button", name=re.compile(r"^(Download|Preview) "))).to_have_count(0)
+        expect(row.get_by_role("button", name=f"Show {name} in the conversation")).to_be_visible()
+
+    # A document an agent created downloads through the personal conversation's own route.
+    word = generated.locator(f"[data-generated-document='{WORD_ID}']")
+    expect(word).to_contain_text("Personal workspace")
+    with page.expect_download() as word_download:
+        word.get_by_role("button", name=f"Download {WORD_NAME}").click()
+    assert word_download.value.suggested_filename == WORD_NAME
+    assert len(api.calls(f"{GENERATED}/{WORD_ID}/download")) == 1
+
+    # An Analyze summary previews in place.
+    summary = generated.locator("[data-generated-file]").filter(has_text=SUMMARY_NAME)
+    expect(summary).to_contain_text("Markdown file")
+    summary.get_by_role("button", name=f"Preview {SUMMARY_NAME}").click()
+    dialog = page.get_by_role("dialog", name=f"Preview {SUMMARY_NAME}")
+    expect(dialog).to_contain_text("Every state has exactly one capital city.")
+    dialog.get_by_role("button", name="Close").click()
+    expect(dialog).to_have_count(0)
+
+
+def test_show_in_conversation_scrolls_to_the_reply_that_made_the_file(drawer_ui):
+    page, api = drawer_ui
+    mount(page, api, "ConversationDrawer", conversation_messages(), drawer="documents")
+    page.evaluate(
+        """() => {
+            const reply = document.createElement('div');
+            reply.id = 'message-a-csv';
+            reply.textContent = 'The reply that rendered the CSV';
+            document.getElementById('mount-b').appendChild(reply);
+        }"""
+    )
+    generated_region(page).get_by_role("button", name=f"Show {CSV_NAME} in the conversation").click()
+    expect(page.locator("#message-a-csv")).to_have_class(re.compile(r"\bring-2\b"))
+
+
+def test_a_conversation_that_produced_nothing_says_so(drawer_ui):
+    page, api = drawer_ui
+    mount(page, api, "ConversationDrawer", [conversation_messages()[0]], drawer="documents")
+    expect(page.get_by_text("No documents yet", exact=True)).to_be_visible()
+    expect(page.get_by_text("Documents used or created while answering will be listed here.")).to_be_visible()
+    expect(generated_region(page)).to_have_count(0)
+    assert api.calls(GENERATED) == [], "no agent-document request for a thread no agent answered"
+
+
+def test_header_badge_counts_generated_files(drawer_ui):
+    page, api = drawer_ui
+    mount(page, api, "ChatExperience", conversation_messages(), entries=["/chat"],
+          used_documents=[{"document_id": "doc-cited", "file_name": "Census tables.pdf"}])
+    documents_button = page.get_by_role("button", name="Open used documents", exact=True)
+    # One document an answer used, the plan's three files, the agent's brief and the summary.
+    expect(documents_button).to_have_text("6")
+    documents_button.click()
+    expect(generated_region(page).locator("li")).to_have_count(5)
+    expect(page.get_by_role("complementary", name="Conversation details")).to_contain_text("Census tables.pdf")
+    assert len(api.calls(GENERATED)) == 1, "the badge and the drawer share one read of the agent documents"
+
+
+def test_a_background_export_that_finishes_becomes_downloadable_in_the_drawer(drawer_ui):
+    page, api = drawer_ui
+    export_reply = message(
+        "a-export", "assistant", "The county seats export is running in the background.",
+        metadata={"generated_tabular_outputs": [{
+            "capability": "tabular", "export_run_id": EXPORT_RUN, "background_export": True,
+            "output_format": "csv", "status": "running",
+        }]},
+    )
+    mount(page, api, "ConversationDrawer", [conversation_messages()[0], export_reply], drawer="documents")
+    generated = generated_region(page)
+    running = generated.locator(f"[data-generated-file='run:{EXPORT_RUN}']")
+    expect(running).to_have_attribute("data-generated-file-status", "pending")
+    expect(running).to_contain_text("Generating")
+
+    # The thread's card polls the run; the drawer follows it without the conversation being reread.
+    page.evaluate("() => window.OrchHarness.mount('mount-a', 'MessageList')")
+    finished = generated.locator("[data-generated-file='artifact:artifact-export']")
+    expect(finished).to_have_attribute("data-generated-file-status", "ready", timeout=15000)
+    expect(finished).to_contain_text(EXPORT_NAME)
+    expect(finished.get_by_role("button", name=f"Download {EXPORT_NAME}")).to_be_visible()
+    expect(running).to_have_count(0)
+    assert api.calls(f"/api/tabular/generated-output/runs/{EXPORT_RUN}"), "the card polled the run"
+
+
+def test_agent_documents_follow_the_attempt_and_masking_the_thread_shows(drawer_ui):
+    page, api = drawer_ui
+    question = conversation_messages()[0]
+    mount(page, api, "ConversationDrawer", [question, agent_reply("a-agent", WORD_ID, WORD_NAME)],
+          drawer="documents")
+    generated = generated_region(page)
+    expect(generated.locator(f"[data-generated-document='{WORD_ID}']")).to_be_visible()
+    assert len(api.calls(GENERATED)) == 1
+
+    # Another attempt of the answer is shown: as many replies as before, but a different one.
+    api.agent_documents = [agent_document(RETRY_ID, RETRY_NAME, "a-agent-2")]
+    with page.expect_request(is_generated_list):
+        set_messages(page, [question, agent_reply("a-agent-2", RETRY_ID, RETRY_NAME)])
+    expect(generated.locator(f"[data-generated-document='{RETRY_ID}']")).to_be_visible()
+    expect(generated.locator(f"[data-generated-document='{WORD_ID}']")).to_have_count(0)
+
+    # Masking the reply hides what it created at once, and the list is read again.
+    api.agent_documents = []
+    with page.expect_request(is_generated_list):
+        set_messages(page, [question, agent_reply("a-agent-2", RETRY_ID, RETRY_NAME, masked=True)])
+    expect(generated_region(page)).to_have_count(0)
+    expect(page.get_by_text("No documents yet", exact=True)).to_be_visible()
+    assert len(api.calls(GENERATED)) == 3
+
+
+def test_a_refused_list_is_asked_again_when_the_drawer_reopens(drawer_ui):
+    page, api = drawer_ui
+    api.list_status = 404
+    question = conversation_messages()[0]
+    mount(page, api, "ConversationDrawer", [question, agent_reply("a-agent", WORD_ID, WORD_NAME)],
+          drawer="documents")
+    # The refusal is answered, and not kept as the final word on this conversation.
+    page.wait_for_function(
+        """() => {
+            const state = window.OrchHarness.stores.generatedDocuments.useGeneratedDocumentsStore.getState();
+            return state.conversationId !== null && state.requestKey === null;
+        }"""
+    )
+    assert len(api.calls(GENERATED)) == 1
+    expect(generated_region(page)).to_have_count(0)
+
+    api.list_status = 200
+    set_drawer(page, None)
+    expect(page.get_by_role("complementary", name="Conversation details")).to_have_count(0)
+    with page.expect_request(is_generated_list):
+        set_drawer(page, "documents")
+    expect(generated_region(page).locator(f"[data-generated-document='{WORD_ID}']")).to_be_visible()
+
+
+def test_returning_to_a_conversation_reads_its_documents_again(drawer_ui):
+    page, api = drawer_ui
+    question = conversation_messages()[0]
+    thread = [question, agent_reply("a-agent", WORD_ID, WORD_NAME)]
+    mount(page, api, "ConversationDrawer", thread, drawer="documents")
+    expect(generated_region(page).locator(f"[data-generated-document='{WORD_ID}']")).to_be_visible()
+
+    # Another conversation, where no agent created anything, so nothing is requested for it.
+    page.evaluate(
+        """() => window.OrchHarness.stores.chat.useChatStore.setState({
+            activeConversationId: 'other-chat',
+            messages: [{ id: 'u-other', conversation_id: 'other-chat', role: 'user', content: 'Hello' }],
+        })"""
+    )
+    expect(generated_region(page)).to_have_count(0)
+
+    # Coming back shows the list as it is now, not as it was when the conversation was left.
+    api.agent_documents = [agent_document(RETRY_ID, RETRY_NAME, "a-agent")]
+    with page.expect_request(is_generated_list):
+        page.evaluate(
+            """(spec) => window.OrchHarness.stores.chat.useChatStore.setState({
+                activeConversationId: spec.conversation, messages: spec.thread,
+            })""",
+            {"conversation": CONVERSATION, "thread": thread},
+        )
+    expect(generated_region(page).locator(f"[data-generated-document='{RETRY_ID}']")).to_be_visible()
+    expect(generated_region(page).locator(f"[data-generated-document='{WORD_ID}']")).to_have_count(0)
+    assert len(api.calls(GENERATED)) == 2