diff --git a/.changeset/app-1004-assistant-chat-design-iteration.md b/.changeset/app-1004-assistant-chat-design-iteration.md
new file mode 100644
index 0000000000..1bec47d525
--- /dev/null
+++ b/.changeset/app-1004-assistant-chat-design-iteration.md
@@ -0,0 +1,6 @@
+---
+"@aragon/assistant-chat": minor
+"@aragon/app": patch
+---
+
+Iterate the support assistant on design feedback: the panel header carries the Aragon mark and names the request being drafted or created, the ticket card leads with the ticket title instead of a "Review your request" label, spent drafts collapse into a quiet line, past requests move from the greeting into their own view reached from under the composer, and the mail escape hatch becomes a footnote there. The transcript opens with a time divider, and the navigation trigger withdraws while the panel is open — the panel collapses through its own chevron.
diff --git a/.changeset/app-1004-assistant-chat-polish.md b/.changeset/app-1004-assistant-chat-polish.md
new file mode 100644
index 0000000000..af9f76102e
--- /dev/null
+++ b/.changeset/app-1004-assistant-chat-polish.md
@@ -0,0 +1,5 @@
+---
+"@aragon/assistant-chat": patch
+---
+
+Send the name and type of an attachment with the conversation (never its bytes), so the assistant can say where a file arrived. The panel header now carries the exact height of the app's navigation bar, so the two bottom borders meet in a line rather than a step, and every control in the widget points at the cursor.
diff --git a/.changeset/app-1004-assistant-resume-and-attachments.md b/.changeset/app-1004-assistant-resume-and-attachments.md
new file mode 100644
index 0000000000..e8f5d387a0
--- /dev/null
+++ b/.changeset/app-1004-assistant-resume-and-attachments.md
@@ -0,0 +1,6 @@
+---
+"@aragon/assistant": patch
+"@aragon/assistant-contracts": patch
+---
+
+Stream every reply against the incoming history, so an approval resume continues the assistant message the draft lives in instead of opening a second one — the sentence written before the tool call was shown again under the created ticket. Attachments now reach the model as a line inside the message that carried them (a `data-attachment` part on the wire, named in the contracts), replacing the positionless "N files are attached" note the model could not place in time: it kept asking for a screenshot the user had just sent.
diff --git a/apps/app/e2e/tests/smoke/supportChat/supportChat.spec.ts b/apps/app/e2e/tests/smoke/supportChat/supportChat.spec.ts
index ae5306d953..2cc4299606 100644
--- a/apps/app/e2e/tests/smoke/supportChat/supportChat.spec.ts
+++ b/apps/app/e2e/tests/smoke/supportChat/supportChat.spec.ts
@@ -102,18 +102,16 @@ test.describe('Support chat', () => {
         await page.goto('/');
         await getChatTrigger(page).click();
 
-        // Panel open: accessible title + greeting message + the persistent email escape hatch.
+        // Panel open: accessible title, the subline naming a fresh conversation, and the greeting.
         const panel = getChatPanel(page);
         await expect(panel).toBeVisible();
         await expect(
-            panel.getByRole('heading', { name: 'Aragon Support Assistant' }),
+            panel.getByRole('heading', { name: 'Aragon Assistant' }),
         ).toBeVisible();
+        await expect(panel.getByText('New conversation')).toBeVisible();
         await expect(
-            page.getByText("Hi! Tell us what's going on"),
+            page.getByText('What do you need help with?'),
         ).toBeVisible();
-        await expect(
-            panel.getByRole('link', { name: 'support@aragon.org' }),
-        ).toHaveAttribute('href', supportEmailHref);
 
         // Send a message; the agent streams back the ticket draft for review.
         const composer = page.getByRole('textbox', { name: 'Message' });
@@ -124,20 +122,32 @@ test.describe('Support chat', () => {
             page.getByText('The proposal page crashes on load.').first(),
         ).toBeVisible();
         await expect(
-            page.getByText('Proposal page crashes', { exact: true }),
+            panel.getByRole('heading', { name: 'Proposal page crashes' }),
         ).toBeVisible();
         await expect(
             panel.getByRole('button', { name: 'Dismiss' }),
         ).toBeVisible();
 
+        // The header names the draft, and the escape hatch to a human now sits under the composer.
+        await expect(
+            panel.getByText('Draft: Proposal page crashes'),
+        ).toBeVisible();
+        await expect(
+            panel.getByRole('link', { name: 'Email support' }),
+        ).toHaveAttribute('href', supportEmailHref);
+
         // Approving resumes the stream: the tool executes and the card links to the ticket.
-        // `exact` keeps the match away from other "Create …" buttons of the page.
-        await panel
-            .getByRole('button', { name: 'Create', exact: true })
-            .click();
+        await panel.getByRole('button', { name: 'Create ticket' }).click();
 
         await expect(page.getByText('Request created')).toBeVisible();
-        await expect(page.getByText('SUP-123')).toBeVisible();
+        await expect(
+            panel.getByRole('link', { name: /SUP-123/ }),
+        ).toHaveAttribute('href', 'https://linear.app/aragon/issue/SUP-123');
+
+        // The header follows the ticket from draft to created.
+        await expect(
+            panel.getByText('SUP-123: Proposal page crashes'),
+        ).toBeVisible();
     });
 
     test('hides the chat entry points and keeps the external support link when the flag is disabled', async ({
diff --git a/apps/app/src/assets/locales/en.json b/apps/app/src/assets/locales/en.json
index f42d84af5a..e00cbc109a 100644
--- a/apps/app/src/assets/locales/en.json
+++ b/apps/app/src/assets/locales/en.json
@@ -424,7 +424,6 @@
           "label": "Support chat"
         },
         "trigger": {
-          "close": "Close support chat",
           "open": "Open support chat"
         }
       },
diff --git a/apps/app/src/modules/application/components/supportChat/supportChat.tsx b/apps/app/src/modules/application/components/supportChat/supportChat.tsx
index 38b5f4f84e..4381951cec 100644
--- a/apps/app/src/modules/application/components/supportChat/supportChat.tsx
+++ b/apps/app/src/modules/application/components/supportChat/supportChat.tsx
@@ -10,7 +10,7 @@ const assistantUrl = process.env.NEXT_PUBLIC_ASSISTANT_URL ?? '';
 
 // The trigger opens the chat whenever the feature flag is on — no availability gate in front of
 // the panel. Service failures surface inside the widget, where mailing the support team stays
-// one click away (header link + error escape hatches).
+// one click away (the line under the composer + error escape hatches).
 export const SupportChat: React.FC = () => {
     const { isOpen, close } = useSupportChatContext();
 
diff --git a/apps/app/src/modules/application/components/supportChat/supportChatTrigger.test.tsx b/apps/app/src/modules/application/components/supportChat/supportChatTrigger.test.tsx
index 08167c29dd..fad1741b86 100644
--- a/apps/app/src/modules/application/components/supportChat/supportChatTrigger.test.tsx
+++ b/apps/app/src/modules/application/components/supportChat/supportChatTrigger.test.tsx
@@ -21,14 +21,14 @@ describe('<SupportChatTrigger /> component', () => {
         } as ReturnType<typeof featureFlagsProvider.useFeatureFlags>);
     };
 
-    const setContext = (isOpen: boolean, toggle = jest.fn()) => {
+    const setContext = (isOpen: boolean, open = jest.fn()) => {
         useSupportChatContextSpy.mockReturnValue({
             isOpen,
-            open: jest.fn(),
+            open,
             close: jest.fn(),
-            toggle,
+            toggle: jest.fn(),
         });
-        return toggle;
+        return open;
     };
 
     beforeEach(() => {
@@ -47,22 +47,32 @@ describe('<SupportChatTrigger /> component', () => {
         expect(screen.queryByRole('button')).not.toBeInTheDocument();
     });
 
-    it('renders an open button and toggles the chat on click', async () => {
-        const toggle = setContext(false);
+    it('renders an open button and opens the chat on click', async () => {
+        const open = setContext(false);
         render(<SupportChatTrigger />);
 
         const button = screen.getByRole('button', {
             name: /supportChat.trigger.open/,
         });
         await userEvent.click(button);
-        expect(toggle).toHaveBeenCalled();
+        expect(open).toHaveBeenCalled();
     });
 
-    it('renders a close button while the chat is open', () => {
+    it('withdraws while the chat is open, which closes through the panel itself', () => {
         setContext(true);
         render(<SupportChatTrigger />);
+        expect(screen.queryByRole('button')).not.toBeInTheDocument();
+    });
+
+    it('takes focus back when the chat is collapsed from the panel', () => {
+        setContext(true);
+        const { rerender } = render(<SupportChatTrigger />);
+
+        setContext(false);
+        rerender(<SupportChatTrigger />);
+
         expect(
-            screen.getByRole('button', { name: /supportChat.trigger.close/ }),
-        ).toBeInTheDocument();
+            screen.getByRole('button', { name: /supportChat.trigger.open/ }),
+        ).toHaveFocus();
     });
 });
diff --git a/apps/app/src/modules/application/components/supportChat/supportChatTrigger.tsx b/apps/app/src/modules/application/components/supportChat/supportChatTrigger.tsx
index 10358733f5..88771110a9 100644
--- a/apps/app/src/modules/application/components/supportChat/supportChatTrigger.tsx
+++ b/apps/app/src/modules/application/components/supportChat/supportChatTrigger.tsx
@@ -1,34 +1,43 @@
 'use client';
 
 import { Button, IconType } from '@aragon/gov-ui-kit';
+import { useEffect, useRef } from 'react';
 import { useFeatureFlags } from '@/shared/components/featureFlagsProvider';
 import { useTranslations } from '@/shared/components/translationsProvider';
 import { useSupportChatContext } from './supportChatContext';
 
-// Header entry point of the support chat: the feedback icon opens the side panel, the chevron
-// (pointing at the panel edge) tucks it away again. Rendered at the trailing edge of the
-// navigation bar (outside the centered container) so it always sits right next to the panel.
+// Header entry point of the support chat. Rendered at the trailing edge of the navigation bar
+// (outside the centered container) so it always sits right next to the panel, and withdrawn while
+// the panel is open — the panel then owns its own collapse control.
 export const SupportChatTrigger: React.FC = () => {
     const { t } = useTranslations();
     const { isEnabled } = useFeatureFlags();
-    const { isOpen, toggle } = useSupportChatContext();
+    const { isOpen, open } = useSupportChatContext();
 
-    if (!isEnabled('supportChat')) {
+    const buttonRef = useRef<HTMLButtonElement>(null);
+    const wasOpen = useRef(false);
+
+    // The trigger withdraws while the panel is open, so collapsing the chat would leave the
+    // keyboard on the document body: focus returns to the trigger that comes back in its place.
+    useEffect(() => {
+        if (!isOpen && wasOpen.current) {
+            buttonRef.current?.focus();
+        }
+
+        wasOpen.current = isOpen;
+    }, [isOpen]);
+
+    if (!isEnabled('supportChat') || isOpen) {
         return null;
     }
 
-    const label = t(
-        isOpen
-            ? 'app.application.supportChat.trigger.close'
-            : 'app.application.supportChat.trigger.open',
-    );
-
     return (
         <div className="flex items-center pr-3 pl-2 lg:pr-4">
             <Button
-                aria-label={label}
-                iconLeft={isOpen ? IconType.CHEVRON_RIGHT : IconType.FEEDBACK}
-                onClick={toggle}
+                aria-label={t('app.application.supportChat.trigger.open')}
+                iconLeft={IconType.FEEDBACK}
+                onClick={open}
+                ref={buttonRef}
                 size="md"
                 variant="tertiary"
             />
diff --git a/apps/assistant/src/chat/prompts/agentPrompt.ts b/apps/assistant/src/chat/prompts/agentPrompt.ts
index 148cd9f1fa..0b5bc51a43 100644
--- a/apps/assistant/src/chat/prompts/agentPrompt.ts
+++ b/apps/assistant/src/chat/prompts/agentPrompt.ts
@@ -16,24 +16,29 @@ const buildContextLine = (appContext?: IAppContext): string => {
         : `\nApp context (for your awareness only — never repeat it back to the user): ${parts}`;
 };
 
-// Metadata of files the user already attached. The model never sees the contents — only that files
-// exist — so it must treat them as received rather than probe the user about them.
-const buildAttachmentLine = (files: { filename: string }[]): string => {
-    if (files.length === 0) {
+// Attachments appear in the conversation as a `[attached: name]` line inside the message that
+// carried them (the bytes stay out-of-band). The model never sees the contents — only that a file
+// arrived — so it must treat it as received rather than probe the user about it.
+const buildAttachmentLine = (hasAttachments: boolean): string => {
+    if (!hasAttachments) {
         return '';
     }
 
-    return `\nThe user has attached ${files.length} file(s) (screenshots, logs, etc.); they travel with the ticket and the support team will read them. Their contents are irrelevant to you and you cannot open them — treat them as safely received. Acknowledge an attachment ONCE, when it first arrives, then never mention it again; never say you "can't see" it, never ask what it shows, and never ask the user to describe, transcribe or re-share it.`;
+    return `\nA line reading "[attached: <name>]" in a user message means the user attached that file right there (screenshots, logs, etc.); it travels with the ticket and the support team will read it. Its contents are irrelevant to you and you cannot open it — treat it as safely received. Acknowledge an attachment ONCE, in your reply to the message that brought it, then never mention it again; never say you "can't see" it, never ask the user to attach it, never ask what it shows, and never ask them to describe, transcribe or re-share it.`;
 };
 
 // The agent's single system prompt: it holds the whole intake conversation, refuses off-topic
 // requests itself (no classifier step) and files tickets through the createLinearTicket tool.
 export const buildAgentSystemPrompt = (params: {
     appContext?: IAppContext;
-    files?: { filename: string }[];
+    hasAttachments?: boolean;
     docsSearchEnabled?: boolean;
 }) => {
-    const { appContext, files = [], docsSearchEnabled = false } = params;
+    const {
+        appContext,
+        hasAttachments = false,
+        docsSearchEnabled = false,
+    } = params;
 
     const docsLine = docsSearchEnabled
         ? '\nYou may use the searchDocs tool to look up Aragon App documentation before deciding whether a question needs a ticket.'
@@ -50,7 +55,7 @@ the user's language, that you can only help with Aragon App feedback, bug report
 requests, and do not file a ticket. You have NO knowledge of how the Aragon App works and you
 never troubleshoot: do not suggest causes, fixes or things to check, and do not answer product
 or how-to questions — warmly offer to file the question for the team
-instead.${buildContextLine(appContext)}${buildAttachmentLine(files)}${docsLine}
+instead.${buildContextLine(appContext)}${buildAttachmentLine(hasAttachments)}${docsLine}
 
 Hold a short, natural conversation — listen and capture, never interrogate. When the user tells
 you something or attaches a file, acknowledge that you have got it. While the story is still
diff --git a/apps/assistant/src/routes/chat.test.ts b/apps/assistant/src/routes/chat.test.ts
index 391b06e05c..33dc59999a 100644
--- a/apps/assistant/src/routes/chat.test.ts
+++ b/apps/assistant/src/routes/chat.test.ts
@@ -250,6 +250,55 @@ describe('POST /chat guardrails', () => {
         expect(streamCalls).not.toContain('tc-2');
     });
 
+    it('shows the model where an attachment arrived in the conversation', async () => {
+        const model = createMockChatModel({});
+        const deps = createTestDependencies(model);
+        const app = buildApp(deps);
+
+        // The bytes travel out-of-band (the widget sends the name only), so the conversation
+        // itself must say that a file came with this message — otherwise the model keeps asking
+        // for a screenshot the user just sent.
+        const body = buildRequestBody();
+        body.messages = [
+            {
+                id: 'message-1',
+                role: 'user',
+                parts: [
+                    { type: 'text', text: 'Here is what I see.' },
+                    {
+                        type: 'data-attachment',
+                        data: { filename: 'screenshot.png' },
+                    },
+                ],
+            } as never,
+        ];
+
+        const response = await app.request('/chat', {
+            method: 'POST',
+            headers: { 'content-type': 'application/json' },
+            body: JSON.stringify(body),
+        });
+        await response.text();
+
+        expect(response.status).toEqual(200);
+        const streamCalls = JSON.stringify(model.doStreamCalls);
+        expect(streamCalls).toContain('[attached: screenshot.png]');
+        // The system prompt explains the marker only when the conversation carries one.
+        expect(streamCalls).toContain('means the user attached that file');
+    });
+
+    it('leaves the attachment guidance out of a conversation without files', async () => {
+        const model = createMockChatModel({});
+        const deps = createTestDependencies(model);
+
+        const response = await postChat(buildApp(deps));
+        await response.text();
+
+        expect(JSON.stringify(model.doStreamCalls)).not.toContain(
+            'means the user attached that file',
+        );
+    });
+
     it('strips replayed reasoning parts from the history before the model call', async () => {
         const model = createMockChatModel({});
         const deps = createTestDependencies(model);
@@ -349,6 +398,18 @@ describe('POST /chat guardrails', () => {
             body: JSON.stringify(buildResumeBody(toolCallId)),
         });
 
+    it('continues the assistant message on a resume instead of opening a second one', async () => {
+        const deps = createTestDependencies(createMockChatModel({}));
+
+        const response = await postResume(buildApp(deps));
+        const streamed = await response.text();
+
+        // The response is stamped with the id of the message the draft lives in, so the widget
+        // continues it. A fresh id makes the widget append a copy of that message — the sentence
+        // written before the tool call would then appear a second time under the created ticket.
+        expect(streamed).toContain('"type":"start","messageId":"message-2"');
+    });
+
     it('does not count an approval resume against the turn budget', async () => {
         const deps = createTestDependencies(createMockChatModel({}));
 
diff --git a/apps/assistant/src/routes/chat.ts b/apps/assistant/src/routes/chat.ts
index 31bc3ff00f..819c3e6fec 100644
--- a/apps/assistant/src/routes/chat.ts
+++ b/apps/assistant/src/routes/chat.ts
@@ -1,5 +1,6 @@
 import {
     assistantLimits,
+    attachmentPartType,
     chatRequestSchema,
     createTicketToolName,
     type IAssistantError,
@@ -61,9 +62,16 @@ const buildFixedMessageResponse = (params: {
     sessionId: string;
     text: string;
     refusalReason: IRefusalReason;
+    originalMessages: UIMessage[];
     failedToolCallIds?: string[];
 }) => {
-    const { sessionId, text, refusalReason, failedToolCallIds } = params;
+    const {
+        sessionId,
+        text,
+        refusalReason,
+        originalMessages,
+        failedToolCallIds,
+    } = params;
 
     observability.logStep({
         sessionId,
@@ -73,6 +81,7 @@ const buildFixedMessageResponse = (params: {
     });
 
     const stream = createUIMessageStream({
+        originalMessages,
         execute: ({ writer }) => {
             writeFixedMessage(writer, text, failedToolCallIds);
         },
@@ -99,6 +108,13 @@ export const buildChatRoute = (deps: IAppDependencies) => {
         const { sessionId, messages, appContext } = parsed.data;
         const sessionStore = deps.getSessionStore();
 
+        // Every stream below is opened against the incoming history: when it ends on an assistant
+        // message (an approval resume), the AI SDK stamps the response with THAT message's id and
+        // the widget continues it. Without it the SDK stamps a fresh id, and the widget — whose
+        // response state is seeded from the last message — appends a copy of it, so the text
+        // written before the tool call is shown a second time under the created ticket.
+        const uiMessages = toUiMessages(messages);
+
         // A session's first turn consumes the per-IP new-session budget. The gate runs BEFORE
         // the turn is counted: a refused session never increments, so retries and concurrent
         // duplicate first turns re-enter the gate (the budget may over-count under concurrency
@@ -137,6 +153,7 @@ export const buildChatRoute = (deps: IAppDependencies) => {
                 sessionId,
                 text: turnLimitMessage,
                 refusalReason: 'turn_limit',
+                originalMessages: uiMessages,
                 failedToolCallIds: pendingApprovedToolCallIds,
             });
         }
@@ -147,6 +164,7 @@ export const buildChatRoute = (deps: IAppDependencies) => {
                 sessionId,
                 text: tokenBudgetMessage,
                 refusalReason: 'token_budget',
+                originalMessages: uiMessages,
                 failedToolCallIds: pendingApprovedToolCallIds,
             });
         }
@@ -159,11 +177,8 @@ export const buildChatRoute = (deps: IAppDependencies) => {
         let respondErrorPayload: string | undefined;
 
         const stream = createUIMessageStream({
+            originalMessages: uiMessages,
             execute: async ({ writer }) => {
-                // File metadata only (never contents): the model must know what is already
-                // attached so it can acknowledge files instead of claiming it "can't see" them.
-                const files = await sessionStore.listFiles(sessionId);
-
                 // Open the message once here; the merged model stream reuses it (sendStart: false)
                 // so the two producers never emit a duplicate start chunk.
                 writer.write({ type: 'start' });
@@ -178,16 +193,15 @@ export const buildChatRoute = (deps: IAppDependencies) => {
                     stopWhen: stepCountIs(5),
                     system: buildAgentSystemPrompt({
                         appContext,
-                        files,
+                        hasAttachments: hasAttachments(messages),
                         docsSearchEnabled,
                     }),
                     // ignoreIncompleteToolCalls drops tool parts the composer's Stop left in
                     // `input-streaming`/`input-available`: replayed as-is they would convert
                     // to a tool call without a response and fail every following model call.
-                    messages: await convertToModelMessages(
-                        toUiMessages(messages),
-                        { ignoreIncompleteToolCalls: true },
-                    ),
+                    messages: await convertToModelMessages(uiMessages, {
+                        ignoreIncompleteToolCalls: true,
+                    }),
                     tools: {
                         [createTicketToolName]: buildCreateLinearTicketTool({
                             deps,
@@ -344,8 +358,42 @@ const getPendingApprovedToolCallIds = (messages: IChatMessage[]): string[] => {
 const toUiMessages = (messages: IChatMessage[]): UIMessage[] =>
     messages
         .map(dropReasoningParts)
+        .map(markAttachments)
         .map(resolveDanglingApprovals) as unknown as UIMessage[];
 
+// Whether the conversation carries any attachment, which is what the attachment guidance in the
+// system prompt is about. Read off the messages, not the session queue: a created ticket empties
+// the queue, and the conversation still remembers the file it took with it.
+const hasAttachments = (messages: IChatMessage[]): boolean =>
+    messages.some((message) =>
+        message.parts.some((part) => part.type === attachmentPartType),
+    );
+
+// Attachments reach the model as a plain line inside the message that carried them: the bytes
+// travel out-of-band, and a positionless "N files are attached" note in the system prompt left the
+// model guessing WHEN a file arrived — it kept asking for screenshots the user had just sent. The
+// line names the file and nothing more. File parts (bytes inline) are never expected here and are
+// reduced to the same line rather than pushed at the model.
+const markAttachments = (message: IChatMessage): IChatMessage => ({
+    ...message,
+    parts: message.parts.map((part) => {
+        if (part.type !== attachmentPartType && part.type !== 'file') {
+            return part;
+        }
+
+        const { data, filename } = part as {
+            data?: { filename?: unknown };
+            filename?: unknown;
+        };
+        const name = data?.filename ?? filename;
+
+        return {
+            type: 'text' as const,
+            text: `[attached: ${typeof name === 'string' ? name : 'a file'}]`,
+        };
+    }),
+});
+
 // Replayed reasoning is dead weight: it feeds no next turn, burns input tokens and makes the
 // gateway log a warning per part on providers that reject non-OpenAI reasoning in history.
 const dropReasoningParts = (message: IChatMessage): IChatMessage => ({
diff --git a/packages/assistant-chat/src/components/assistantChat/assistantChat.test.tsx b/packages/assistant-chat/src/components/assistantChat/assistantChat.test.tsx
index 5f42c64be4..afb92c4d63 100644
--- a/packages/assistant-chat/src/components/assistantChat/assistantChat.test.tsx
+++ b/packages/assistant-chat/src/components/assistantChat/assistantChat.test.tsx
@@ -168,16 +168,18 @@ describe('<AssistantChat /> integration', () => {
         global.fetch = originalFetch;
     });
 
+    const widget = (isOpen = true, monitoring?: IChatMonitoring) => (
+        <AssistantChat
+            appContext={{ route: '/dashboard', appVersion: '1.0.0' }}
+            assistantUrl={assistantUrl}
+            isOpen={isOpen}
+            monitoring={monitoring}
+            onClose={jest.fn()}
+        />
+    );
+
     const renderWidget = (monitoring?: IChatMonitoring) =>
-        render(
-            <AssistantChat
-                appContext={{ route: '/dashboard', appVersion: '1.0.0' }}
-                assistantUrl={assistantUrl}
-                isOpen={true}
-                monitoring={monitoring}
-                onClose={jest.fn()}
-            />,
-        );
+        render(widget(true, monitoring));
 
     const sendMessageAndReviewDraft = async () => {
         const composer = await screen.findByRole('textbox', {
@@ -193,7 +195,7 @@ describe('<AssistantChat /> integration', () => {
             await screen.findByText('Proposal page crashes on load'),
         ).toBeInTheDocument();
 
-        return screen.getByRole('button', { name: 'Create' });
+        return screen.getByRole('button', { name: 'Create ticket' });
     };
 
     it('drafts the ticket, creates it on approval and links to it', async () => {
@@ -208,6 +210,12 @@ describe('<AssistantChat /> integration', () => {
             screen.getByRole('button', { name: 'Dismiss' }),
         ).toBeInTheDocument();
 
+        // The transcript opens with the time it started, the header names the draft in progress.
+        expect(screen.getByText(/^Today \d{2}:\d{2}$/)).toBeInTheDocument();
+        expect(
+            screen.getByText('Draft: Proposal page crashes on load'),
+        ).toBeInTheDocument();
+
         await userEvent.click(createButton);
 
         // Approval resumes the stream (a second /chat call) and the tool output renders as success.
@@ -215,6 +223,11 @@ describe('<AssistantChat /> integration', () => {
         expect(screen.getByText('SUP-123')).toBeInTheDocument();
         expect(chatCalls()).toHaveLength(2);
 
+        // The header follows the ticket from draft to created.
+        expect(
+            screen.getByText('SUP-123: Proposal page crashes on load'),
+        ).toBeInTheDocument();
+
         // The created ticket is remembered in the device-local history.
         expect(
             JSON.parse(
@@ -249,7 +262,7 @@ describe('<AssistantChat /> integration', () => {
         // Retry re-drafts; approving the fresh draft creates the ticket.
         await userEvent.click(screen.getByRole('button', { name: 'Retry' }));
         await userEvent.click(
-            await screen.findByRole('button', { name: 'Create' }),
+            await screen.findByRole('button', { name: 'Create ticket' }),
         );
 
         expect(await screen.findByText('Request created')).toBeInTheDocument();
@@ -305,16 +318,110 @@ describe('<AssistantChat /> integration', () => {
             screen.queryByRole('button', { name: 'Remove file' }),
         ).not.toBeInTheDocument();
 
-        // The preview stays local: the chat request carries no file parts.
+        // The bytes stay local: the request names the attachment (so the service can show the
+        // model where it arrived) and carries nothing else of it.
         const [, chatRequest] = chatCalls()[0];
         const requestBody = JSON.parse(chatRequest?.body as string) as {
-            messages: { parts: { type: string }[] }[];
+            messages: { parts: Record<string, unknown>[] }[];
         };
         const requestParts = requestBody.messages.flatMap(
             (message) => message.parts,
         );
-        expect(requestParts.length).toBeGreaterThan(0);
-        expect(requestParts.every((part) => part.type !== 'file')).toBe(true);
+        expect(requestParts).toContainEqual({
+            type: 'data-attachment',
+            data: { filename: 'screenshot.png' },
+        });
+        expect(chatRequest?.body).not.toContain('data:image/png;base64');
+    });
+
+    it('opens the requests filed from this device from the link under the composer', async () => {
+        localStorage.setItem(
+            'aragon-assistant:requests',
+            JSON.stringify([
+                {
+                    identifier: 'SUP-1',
+                    url: 'https://linear.app/aragon/issue/SUP-1',
+                    summary: 'Treasury shows a stale balance',
+                    createdAt: '2026-07-24T10:00:00.000Z',
+                },
+            ]),
+        );
+        renderWidget();
+
+        await userEvent.click(
+            await screen.findByRole('button', { name: 'Past requests (1)' }),
+        );
+
+        // The requests take over the panel: the entry deep-links to the ticket, the composer is
+        // gone until the user comes back to the conversation.
+        expect(
+            screen.getByRole('link', {
+                name: /Treasury shows a stale balance/,
+            }),
+        ).toHaveAttribute('href', 'https://linear.app/aragon/issue/SUP-1');
+        expect(
+            screen.queryByRole('textbox', { name: 'Message' }),
+        ).not.toBeInTheDocument();
+
+        await userEvent.click(
+            screen.getByRole('button', { name: 'Back to chat' }),
+        );
+        expect(
+            await screen.findByRole('textbox', { name: 'Message' }),
+        ).toBeInTheDocument();
+    });
+
+    it('leaves the requests behind when the panel is closed while showing them', async () => {
+        localStorage.setItem(
+            'aragon-assistant:requests',
+            JSON.stringify([
+                {
+                    identifier: 'SUP-1',
+                    url: 'https://linear.app/aragon/issue/SUP-1',
+                    summary: 'Treasury shows a stale balance',
+                    createdAt: '2026-07-24T10:00:00.000Z',
+                },
+            ]),
+        );
+        const { rerender } = renderWidget();
+
+        await userEvent.click(
+            await screen.findByRole('button', { name: 'Past requests (1)' }),
+        );
+        expect(
+            screen.queryByRole('textbox', { name: 'Message' }),
+        ).not.toBeInTheDocument();
+
+        // Reopening lands on the conversation, not on the detour the panel was closed from.
+        rerender(widget(false));
+        rerender(widget(true));
+
+        expect(
+            await screen.findByRole('textbox', { name: 'Message' }),
+        ).toBeInTheDocument();
+    });
+
+    it('stops naming a draft in the header once the user dismisses it', async () => {
+        chatResponses = [
+            createChatResponse(draftChunks('tc-1')),
+            createChatResponse(textChunks('No problem, the draft is gone.')),
+        ];
+        renderWidget();
+
+        await sendMessageAndReviewDraft();
+        await userEvent.click(screen.getByRole('button', { name: 'Dismiss' }));
+
+        // The card says the draft was dismissed, so nothing is being worked on: the header drops
+        // back to naming a fresh conversation.
+        expect(
+            await screen.findByText(
+                'Draft dismissed. Keep chatting to prepare a new one.',
+            ),
+        ).toBeInTheDocument();
+        expect(
+            screen.queryByText('Draft: Proposal page crashes on load'),
+        ).not.toBeInTheDocument();
+        expect(screen.getByText('New conversation')).toBeInTheDocument();
     });
 
     it('marks an unapproved draft as superseded when the user keeps typing', async () => {
@@ -335,7 +442,7 @@ describe('<AssistantChat /> integration', () => {
         // The undecided draft is spent quietly — no error wording, no lingering Create button.
         expect(
             screen.getByText(
-                'This draft was set aside after your newer messages.',
+                'Earlier draft set aside — your newer messages replaced it.',
             ),
         ).toBeInTheDocument();
         expect(
@@ -344,8 +451,9 @@ describe('<AssistantChat /> integration', () => {
             ),
         ).not.toBeInTheDocument();
         expect(
-            screen.queryByRole('button', { name: 'Create' }),
+            screen.queryByRole('button', { name: 'Create ticket' }),
         ).not.toBeInTheDocument();
+        expect(screen.getByText('New conversation')).toBeInTheDocument();
 
         // The pending approval travels to the server untouched, where it resolves as superseded —
         // the client must not rewrite it into a tool error.
diff --git a/packages/assistant-chat/src/components/assistantChat/assistantChat.tsx b/packages/assistant-chat/src/components/assistantChat/assistantChat.tsx
index 8d10b12c62..dbb1524255 100644
--- a/packages/assistant-chat/src/components/assistantChat/assistantChat.tsx
+++ b/packages/assistant-chat/src/components/assistantChat/assistantChat.tsx
@@ -1,9 +1,10 @@
 import { AssistantRuntimeProvider } from '@assistant-ui/react';
-import { useCallback } from 'react';
+import { useCallback, useEffect, useState } from 'react';
 import { noopMonitoring } from '../../monitoring';
 import { useAssistantRuntime } from '../../runtime';
 import { useChatSession } from '../../session';
 import { ChatHeader } from '../chatHeader';
+import { ChatRequestHistory } from '../chatRequestHistory';
 import { Thread } from '../thread';
 import type { IAssistantChatProps } from './assistantChat.api';
 
@@ -23,6 +24,18 @@ export const AssistantChat: React.FC<IAssistantChatProps> = (props) => {
 
     const { sessionId, rotate } = useChatSession();
 
+    // The panel shows either the conversation or the requests filed from this device; the composer
+    // lives inside the thread, so swapping the thread out is what hides it in the requests view.
+    const [isViewingRequests, setIsViewingRequests] = useState(false);
+
+    // The requests are a detour off the conversation, not a place to come back to: closing the
+    // panel drops the detour, so reopening lands on the chat the user was having.
+    useEffect(() => {
+        if (!isOpen) {
+            setIsViewingRequests(false);
+        }
+    }, [isOpen]);
+
     const runtime = useAssistantRuntime({
         assistantUrl,
         sessionId,
@@ -38,13 +51,26 @@ export const AssistantChat: React.FC<IAssistantChatProps> = (props) => {
         void runtime.thread.composer.clearAttachments();
         // The runtime starts a fresh thread when the session identifier changes.
         rotate();
+        setIsViewingRequests(false);
     }, [runtime, rotate]);
 
     return (
         <AssistantRuntimeProvider runtime={runtime}>
             <div className="flex h-full min-h-0 flex-col">
-                <ChatHeader onClose={onClose} onNewChat={startNewChat} />
-                <Thread isOpen={isOpen} />
+                <ChatHeader
+                    isViewingRequests={isViewingRequests}
+                    onBack={() => setIsViewingRequests(false)}
+                    onClose={onClose}
+                    onNewChat={startNewChat}
+                />
+                {isViewingRequests ? (
+                    <ChatRequestHistory />
+                ) : (
+                    <Thread
+                        isOpen={isOpen}
+                        onViewRequests={() => setIsViewingRequests(true)}
+                    />
+                )}
             </div>
         </AssistantRuntimeProvider>
     );
diff --git a/packages/assistant-chat/src/components/attachment/attachment.tsx b/packages/assistant-chat/src/components/attachment/attachment.tsx
index fbcd1c2592..556697094b 100644
--- a/packages/assistant-chat/src/components/attachment/attachment.tsx
+++ b/packages/assistant-chat/src/components/attachment/attachment.tsx
@@ -101,7 +101,7 @@ const AttachmentPreviewDialog: React.FC<PropsWithChildren> = (props) => {
                     <Dialog.Close asChild={true}>
                         <TooltipIconButton
                             className="absolute top-4 right-4 bg-neutral-0/80 text-neutral-800 hover:bg-neutral-0"
-                            tooltip={chatCopy.header.close}
+                            tooltip={chatCopy.attachments.closePreview}
                             variant="unstyled"
                         >
                             <Icon icon={IconType.CLOSE} size="sm" />
diff --git a/packages/assistant-chat/src/components/chatHeader/aragonMark.tsx b/packages/assistant-chat/src/components/chatHeader/aragonMark.tsx
new file mode 100644
index 0000000000..b5a76263cc
--- /dev/null
+++ b/packages/assistant-chat/src/components/chatHeader/aragonMark.tsx
@@ -0,0 +1,22 @@
+// The widget carries its own copy of the mark: it must not reach into the host app, and gov-ui-kit
+// ships no Aragon logo. Kept in sync with apps/app/src/shared/components/aragonLogo/aragonLogoIcon.
+export const AragonMark: React.FC = () => (
+    <svg
+        aria-hidden="true"
+        className="size-9 flex-none text-primary-400"
+        fill="none"
+        viewBox="0 0 32 32"
+        xmlns="http://www.w3.org/2000/svg"
+    >
+        <path
+            clipRule="evenodd"
+            d="M12.7362 1.637 11.2731.0866c2.5301-.3256 9.2058.092 15.6684 4.3666.084.5904.0659 1.1789.0659 1.1789l.4763.2575.0027.004.001-.006.0098.006c.2671.4582.537 1.1412.7095 1.9448.2087.9725.2682 2.092.0248 3.1627-.2451 1.0788-.7105 1.9691-1.1661 2.6203-.3367.4812-.6578.8176-.8687 1.0018-.8255.0173-2.3624.5703-2.8017 2.4879-1.3239.7566-3.4022 1.513-6.1474 1.513-2.6224 0-5.2973-.7586-7.3082-2.2275-2.0028-1.463-3.3478-3.6287-3.3478-6.4799 0-2.268 1.0177-4.0398 2.3084-5.3428 1.2949-1.3072 3.065-2.3663 4.0916-2.7178l-.2554-.219Zm11.3405 3.7208c-.5088.5538-.9845.8196-1.1203.8916-2.971-.6605-4.0414-2.2668-4.0414-2.2668 2.8024-.0181 5.3317.6785 7.1823 1.857 0 0-1.0018-.3393-2.0206-.4818Z"
+            fill="currentColor"
+            fillRule="evenodd"
+        />
+        <path
+            d="M11.2316 2.0661C4.8616 3.3474 0 9.0764 0 16.0043 0 24.763 7.4034 32 16.5359 32c6.8195 0 12.496-4.1696 15.4641-9.7482-3.9474.9361-8.6604-.7283-8.6905-4.3667-1.4209.7304-3.467 1.3789-6.0619 1.3789-2.7349 0-5.5479-.7891-7.6857-2.3507-2.146-1.5676-3.6103-3.9156-3.6103-6.9967 0-2.4777 1.1166-4.403 2.4937-5.7932.7967-.7967 1.8891-1.5528 2.7863-2.0573ZM28.8325 7.704a8.6246 8.6246 0 0 0-.3222-1.128c1.7124 1.2797 3.0459 3.026 2.9348 5.4593-.16 3.5047-2.277 4.8836-3.6324 5.1135.6505-1.0917.1084-1.7811-.1085-2.011-.1055-.1118-.3233-.3001-.6973-.4176a7.3132 7.3132 0 0 0 .5829-.732c.4937-.7056.999-1.6712 1.2658-2.8453.2687-1.1821.2001-2.3986-.0231-3.4389Z"
+            fill="currentColor"
+        />
+    </svg>
+);
diff --git a/packages/assistant-chat/src/components/chatHeader/chatHeader.tsx b/packages/assistant-chat/src/components/chatHeader/chatHeader.tsx
index f1bc7c5c19..89edd88ae1 100644
--- a/packages/assistant-chat/src/components/chatHeader/chatHeader.tsx
+++ b/packages/assistant-chat/src/components/chatHeader/chatHeader.tsx
@@ -1,17 +1,25 @@
 import {
-    AvatarIcon,
-    Button,
-    Heading,
-    Icon,
-    IconType,
-} from '@aragon/gov-ui-kit';
-import { useAuiState } from '@assistant-ui/react';
-import { chatCopy, supportEmail, supportEmailHref } from '../../copy';
+    createTicketToolName,
+    type ICreateTicketToolInput,
+    type ICreateTicketToolOutput,
+} from '@aragon/assistant-contracts';
+import { Heading, Icon, IconType } from '@aragon/gov-ui-kit';
+import { type AssistantState, useAuiState } from '@assistant-ui/react';
+import { chatCopy } from '../../copy';
 import { TooltipIconButton } from '../tooltipIconButton';
+import { AragonMark } from './aragonMark';
 
 export interface IChatHeaderProps {
     /**
-     * Called when the close button is pressed.
+     * Whether the panel currently shows the past requests instead of the conversation.
+     */
+    isViewingRequests: boolean;
+    /**
+     * Returns from the past requests to the conversation.
+     */
+    onBack: () => void;
+    /**
+     * Called when the collapse button is pressed.
      */
     onClose: () => void;
     /**
@@ -20,47 +28,112 @@ export interface IChatHeaderProps {
     onNewChat: () => void;
 }
 
+type MessagePart =
+    AssistantState['thread']['messages'][number]['parts'][number];
+
+const isTicketPart = (part: MessagePart) =>
+    part.type === 'tool-call' && part.toolName === createTicketToolName;
+
+// Names the object the conversation is working on: the title of the draft being assembled, or the
+// created ticket once the tool returned. Spent drafts name nothing — the same states the ticket
+// card collapses into a quiet line drop the header back to the fresh-conversation subline.
+const useTicketContext = (): string | undefined =>
+    useAuiState((state) => {
+        const { messages } = state.thread;
+
+        // The last ticket of the thread is the one the header speaks about; its message position
+        // tells a superseded draft (the user kept typing past it) from a live one.
+        const messageIndex = messages.findLastIndex((message) =>
+            message.parts.some(isTicketPart),
+        );
+        const ticket = messages[messageIndex]?.parts.findLast(isTicketPart);
+
+        if (ticket?.type !== 'tool-call') {
+            return undefined;
+        }
+
+        // Arguments stream in as a partial parse, so the title may not have arrived yet.
+        const { title } = ticket.args as Partial<ICreateTicketToolInput>;
+
+        if (title == null) {
+            return undefined;
+        }
+
+        const result = ticket.result as ICreateTicketToolOutput | undefined;
+        const { approval, isError } = ticket;
+
+        if (result != null && isError !== true) {
+            return `${result.identifier}: ${title}`;
+        }
+
+        // Mirrors the spent states of the card: the user dismissed or cancelled the draft, kept
+        // typing past it, or it never came through. A creation that was attempted and failed keeps
+        // its title — that card still offers a retry.
+        const isDismissed =
+            approval?.approved === false || approval?.resolution != null;
+        const isSuperseded =
+            approval?.approved == null && messageIndex < messages.length - 1;
+        const isInterrupted = isError === true && approval?.approved !== true;
+
+        if (isDismissed || isSuperseded || isInterrupted) {
+            return undefined;
+        }
+
+        return `${chatCopy.header.contextDraftPrefix} ${title}`;
+    });
+
 export const ChatHeader: React.FC<IChatHeaderProps> = (props) => {
-    const { onClose, onNewChat } = props;
+    const { isViewingRequests, onBack, onClose, onNewChat } = props;
 
     const isEmpty = useAuiState((state) => state.thread.messages.length === 0);
+    const ticketContext = useTicketContext();
+
+    const context = isViewingRequests
+        ? chatCopy.requestHistory.heading
+        : (ticketContext ?? chatCopy.header.contextNew);
 
+    // The header stands next to the app's navigation bar and carries its exact height (20px of
+    // padding around a 50px control row, plus the 1px rule): anything else meets the bar's bottom
+    // border in a step at the panel edge.
     return (
-        <div className="relative flex flex-none items-center gap-2.5 bg-gradient-to-b from-neutral-50 to-transparent py-3 pr-13 pl-5">
-            <AvatarIcon icon={IconType.FEEDBACK} size="md" variant="primary" />
-            <Heading as="h2" size="h4">
-                {chatCopy.header.title}
-            </Heading>
-            <div className="ml-auto flex items-center gap-1">
-                {/* Always-visible escape hatch: users who prefer not to chat can mail the support
-                    team directly, in every state, not only on failures. The tooltip carries the
-                    full address. */}
+        <div className="flex min-h-[91px] flex-none items-center gap-3.5 border-neutral-100 border-b pr-3.5 pl-5">
+            {isViewingRequests ? (
                 <TooltipIconButton
-                    href={supportEmailHref}
-                    tooltip={supportEmail}
+                    onClick={onBack}
+                    tooltip={chatCopy.header.back}
                 >
-                    <Icon icon={IconType.SOCIAL_EMAIL} size="sm" />
+                    <Icon icon={IconType.CHEVRON_LEFT} size="sm" />
                 </TooltipIconButton>
+            ) : (
+                <AragonMark />
+            )}
+            <div className="flex min-w-0 flex-col">
+                <Heading as="h2" size="h4">
+                    {chatCopy.header.title}
+                </Heading>
+                <p className="truncate text-neutral-400 text-xs">{context}</p>
+            </div>
+            <div className="ml-auto flex items-center gap-1">
                 {/* One conversation can file several tickets, so a fresh start is always offered —
                     it rotates the session and clears the transcript. Hidden on an already-empty
                     chat where it would do nothing. */}
-                {!isEmpty && (
+                {!(isEmpty || isViewingRequests) && (
                     <TooltipIconButton
                         onClick={onNewChat}
                         tooltip={chatCopy.header.startNewChat}
                     >
-                        <Icon icon={IconType.PEN} size="sm" />
+                        <Icon icon={IconType.PLUS} size="sm" />
                     </TooltipIconButton>
                 )}
+                {/* The chevron points at the panel edge the chat tucks away to; the navigation
+                    trigger brings it back. */}
+                <TooltipIconButton
+                    onClick={onClose}
+                    tooltip={chatCopy.header.collapse}
+                >
+                    <Icon icon={IconType.CHEVRON_RIGHT} size="sm" />
+                </TooltipIconButton>
             </div>
-            <Button
-                aria-label={chatCopy.header.close}
-                className="!absolute top-3 right-3"
-                iconLeft={IconType.CLOSE}
-                onClick={onClose}
-                size="sm"
-                variant="tertiary"
-            />
         </div>
     );
 };
diff --git a/packages/assistant-chat/src/components/chatRequestHistory/chatRequestHistory.tsx b/packages/assistant-chat/src/components/chatRequestHistory/chatRequestHistory.tsx
index fbf1fbfa1f..08e38fd5fe 100644
--- a/packages/assistant-chat/src/components/chatRequestHistory/chatRequestHistory.tsx
+++ b/packages/assistant-chat/src/components/chatRequestHistory/chatRequestHistory.tsx
@@ -1,9 +1,6 @@
 import { Tag } from '@aragon/gov-ui-kit';
-import { useState } from 'react';
 import { chatCopy } from '../../copy';
-import { getRequestHistory } from '../../requests';
-
-const maxVisibleEntries = 5;
+import { useRequestHistory } from '../../requests';
 
 const dateFormatter = new Intl.DateTimeFormat('en-US', {
     month: 'short',
@@ -16,35 +13,35 @@ const formatCreatedAt = (createdAt: string): string => {
     return Number.isNaN(date.getTime()) ? '' : dateFormatter.format(date);
 };
 
-// Past requests of this device, shown on the greeting screen so users can get back to a created
-// ticket without digging through their email. The component only exists on the greeting screen,
-// so reading the stored history once per mount is always fresh: any newly created ticket
-// unmounts the greeting, and the next fresh chat remounts it.
+// The requests filed from this device, as a view of their own reached from the link under the
+// composer. The entries deep-link to the created ticket — the conversations themselves are not
+// restorable, they live for the length of a session.
 export const ChatRequestHistory: React.FC = () => {
-    const [requestHistory] = useState(() => getRequestHistory());
+    const requestHistory = useRequestHistory();
 
     if (requestHistory.length === 0) {
-        return null;
+        return (
+            <p className="flex flex-1 items-center justify-center p-6 text-center text-neutral-400 text-sm">
+                {chatCopy.requestHistory.empty}
+            </p>
+        );
     }
 
     return (
-        <div className="mt-8 flex flex-col gap-2 self-stretch text-start">
-            <p className="text-neutral-500 text-xs uppercase tracking-wide">
-                {chatCopy.requestHistory.heading}
-            </p>
-            {requestHistory.slice(0, maxVisibleEntries).map((entry) => (
+        <div className="flex min-h-0 flex-1 flex-col gap-2 overflow-y-auto overscroll-contain p-4 [scrollbar-width:none] [&::-webkit-scrollbar]:hidden">
+            {requestHistory.map((entry) => (
                 <a
-                    className="flex items-center gap-2 rounded-xl border border-neutral-100 bg-neutral-0 px-2.5 py-2 transition-colors hover:border-neutral-200 hover:bg-neutral-50"
+                    className="flex flex-none items-center gap-3 rounded-xl border border-neutral-100 bg-neutral-0 px-4 py-3 shadow-neutral transition-colors hover:border-neutral-200 hover:bg-neutral-50"
                     href={entry.url}
                     key={entry.identifier}
                     rel="noreferrer"
                     target="_blank"
                 >
                     <Tag label={entry.identifier} variant="primary" />
-                    <span className="min-w-0 flex-1 truncate text-neutral-800 text-xs">
+                    <span className="min-w-0 flex-1 truncate text-neutral-800 text-sm">
                         {entry.summary}
                     </span>
-                    <span className="flex-none text-neutral-300 text-xs">
+                    <span className="flex-none text-neutral-400 text-sm">
                         {formatCreatedAt(entry.createdAt)}
                     </span>
                 </a>
diff --git a/packages/assistant-chat/src/components/createTicketCard/createTicketCard.tsx b/packages/assistant-chat/src/components/createTicketCard/createTicketCard.tsx
index 12c20479bd..ce10d24fa3 100644
--- a/packages/assistant-chat/src/components/createTicketCard/createTicketCard.tsx
+++ b/packages/assistant-chat/src/components/createTicketCard/createTicketCard.tsx
@@ -21,7 +21,12 @@ import { appendRequestToHistory } from '../../requests';
 
 // The top margin separates the card from the assistant text preceding it in the same message.
 const cardClassName =
-    'mt-3 flex w-full flex-col gap-3 rounded-xl border border-neutral-100 bg-neutral-0 p-4 first:mt-0';
+    'mt-3 flex w-full flex-col gap-3.5 rounded-xl border border-neutral-100 bg-neutral-0 p-5 shadow-neutral-md first:mt-0';
+
+// A draft nobody acted on is not an event worth a card: it collapses into a quiet line so the
+// transcript stays readable while still reading honestly.
+const spentNoteClassName =
+    'mt-3 text-center text-neutral-400 text-xs leading-normal first:mt-0';
 
 // The ticket draft the model assembled, rendered as an approval card in the transcript. It walks
 // four states: the draft streaming in, the draft awaiting the user's Create/Dismiss decision, the
@@ -87,15 +92,12 @@ export const CreateTicketCard: ToolCallMessagePartComponent<
     }
 
     // A draft that broke before the user ever approved it (clipped stream, invalid tool input)
-    // is not a failed creation — nothing was attempted. Render it as a quiet spent card so the
-    // conversation just moves on.
+    // is not a failed creation — nothing was attempted, so the conversation just moves on.
     if (isError && approval?.approved !== true) {
         return (
-            <div className={cardClassName}>
-                <p className="text-neutral-400 text-sm leading-normal">
-                    {chatCopy.ticketCard.draftInterrupted}
-                </p>
-            </div>
+            <p className={spentNoteClassName}>
+                {chatCopy.ticketCard.draftInterrupted}
+            </p>
         );
     }
 
@@ -131,26 +133,21 @@ export const CreateTicketCard: ToolCallMessagePartComponent<
     }
 
     // Superseded draft: the user kept typing past an undecided card, so the approval was never
-    // answered — the server resolves it as superseded and a fresh draft follows. A quiet spent
-    // card, kept in place so the transcript reads honestly.
+    // answered — the server resolves it as superseded and a fresh draft follows.
     if (approval?.approved == null && !isLastMessage) {
         return (
-            <div className={cardClassName}>
-                <p className="text-neutral-400 text-sm leading-normal">
-                    {chatCopy.ticketCard.superseded}
-                </p>
-            </div>
+            <p className={spentNoteClassName}>
+                {chatCopy.ticketCard.superseded}
+            </p>
         );
     }
 
     // Dismissed or cancelled draft: the user explicitly declined it.
     if (approval?.approved === false || approval?.resolution != null) {
         return (
-            <div className={cardClassName}>
-                <p className="text-neutral-400 text-sm leading-normal">
-                    {chatCopy.ticketCard.dismissed}
-                </p>
-            </div>
+            <p className={spentNoteClassName}>
+                {chatCopy.ticketCard.dismissed}
+            </p>
         );
     }
 
@@ -180,38 +177,23 @@ export const CreateTicketCard: ToolCallMessagePartComponent<
 
     return (
         <div className={cardClassName}>
-            <div className="flex items-center justify-between gap-2">
-                <Heading as="h3" size="h5">
-                    {chatCopy.ticketCard.draftHeading}
-                </Heading>
-                {args.intent != null && (
-                    <Tag
-                        label={chatCopy.ticketCard.intentLabel[args.intent]}
-                        variant="neutral"
-                    />
-                )}
-            </div>
+            {/* The ticket leads with itself: its title is the card's heading. */}
             {args.title != null && (
-                <p className="font-semibold text-neutral-800 text-sm leading-normal">
+                <Heading as="h3" size="h4">
                     {args.title}
-                </p>
+                </Heading>
             )}
             {args.description != null && (
-                <div className="flex flex-col gap-0.5">
-                    <p className="text-neutral-500 text-xs uppercase tracking-wide">
-                        {chatCopy.ticketCard.descriptionLabel}
-                    </p>
-                    <p className="whitespace-pre-wrap text-neutral-800 text-sm leading-normal">
-                        {args.description}
-                    </p>
-                </div>
+                <p className="whitespace-pre-wrap text-neutral-600 text-sm leading-normal">
+                    {args.description}
+                </p>
             )}
             {steps.length > 0 && (
-                <div className="flex flex-col gap-0.5">
-                    <p className="text-neutral-500 text-xs uppercase tracking-wide">
+                <div className="flex flex-col gap-1">
+                    <p className="font-semibold text-neutral-800 text-sm leading-normal">
                         {chatCopy.ticketCard.stepsLabel}
                     </p>
-                    <ol className="list-decimal pl-5 text-neutral-800 text-sm leading-normal">
+                    <ol className="list-decimal pl-5 text-neutral-600 text-sm leading-normal">
                         {steps.map((step, index) => (
                             // Steps are positional and may repeat verbatim, so the index is the
                             // only stable identity available.
@@ -220,16 +202,6 @@ export const CreateTicketCard: ToolCallMessagePartComponent<
                     </ol>
                 </div>
             )}
-            {args.contact != null && args.contact.length > 0 && (
-                <div className="flex flex-col gap-0.5">
-                    <p className="text-neutral-500 text-xs uppercase tracking-wide">
-                        {chatCopy.ticketCard.contactLabel}
-                    </p>
-                    <p className="text-neutral-800 text-sm leading-normal">
-                        {args.contact}
-                    </p>
-                </div>
-            )}
             {awaitingDecision ? (
                 <>
                     {/* Deterministic invite to enrich the request: the model does not reliably
@@ -237,12 +209,17 @@ export const CreateTicketCard: ToolCallMessagePartComponent<
                     <p className="text-neutral-400 text-xs leading-normal">
                         {chatCopy.ticketCard.addMore}
                     </p>
-                    <div className="flex items-center gap-2 pt-1">
+                    {args.contact != null && args.contact.length > 0 && (
+                        <p className="text-neutral-400 text-xs leading-normal">
+                            {`${chatCopy.ticketCard.contactPrefix} ${args.contact}`}
+                        </p>
+                    )}
+                    <div className="flex items-center gap-3 border-neutral-100 border-t pt-3.5">
                         <Button
                             onClick={() =>
                                 respondToApproval({ approved: true })
                             }
-                            size="sm"
+                            size="md"
                             variant="primary"
                         >
                             {chatCopy.ticketCard.create}
@@ -256,7 +233,7 @@ export const CreateTicketCard: ToolCallMessagePartComponent<
                                     reason: 'The user dismissed the draft.',
                                 })
                             }
-                            size="sm"
+                            size="md"
                             variant="tertiary"
                         >
                             {chatCopy.ticketCard.dismiss}
diff --git a/packages/assistant-chat/src/components/thread/thread.tsx b/packages/assistant-chat/src/components/thread/thread.tsx
index 51c2372384..356da7b393 100644
--- a/packages/assistant-chat/src/components/thread/thread.tsx
+++ b/packages/assistant-chat/src/components/thread/thread.tsx
@@ -1,4 +1,5 @@
-import { Icon, IconType, Spinner } from '@aragon/gov-ui-kit';
+import { createTicketToolName } from '@aragon/assistant-contracts';
+import { Heading, Icon, IconType, Spinner } from '@aragon/gov-ui-kit';
 import {
     ActionBarPrimitive,
     type AssistantState,
@@ -12,13 +13,13 @@ import {
 } from '@assistant-ui/react';
 import { useEffect, useRef } from 'react';
 import { chatCopy, supportEmailHref } from '../../copy';
+import { useRequestHistory } from '../../requests';
 import { getAssistantErrorText, parseAssistantError } from '../../transport';
 import {
     ComposerAddAttachment,
     ComposerAttachments,
     UserMessageAttachments,
 } from '../attachment';
-import { ChatRequestHistory } from '../chatRequestHistory';
 import { CreateTicketCard } from '../createTicketCard';
 import { MarkdownText } from '../markdownText';
 import { TooltipIconButton } from '../tooltipIconButton';
@@ -35,6 +36,10 @@ export interface IThreadProps {
      * Whether the chat is currently visible; the composer grabs focus when it becomes true.
      */
     isOpen: boolean;
+    /**
+     * Opens the requests filed from this device.
+     */
+    onViewRequests: () => void;
 }
 
 // Startup exposes a loading placeholder thread; treat it as a new chat so the welcome screen
@@ -44,7 +49,7 @@ const isNewChatView = (state: AssistantState) =>
     (!state.thread.isLoading || state.threads.isLoading);
 
 export const Thread: React.FC<IThreadProps> = (props) => {
-    const { isOpen } = props;
+    const { isOpen, onViewRequests } = props;
 
     return (
         <ThreadPrimitive.Root
@@ -52,8 +57,6 @@ export const Thread: React.FC<IThreadProps> = (props) => {
             style={
                 {
                     '--thread-max-width': '100%',
-                    '--composer-bg':
-                        'color-mix(in oklab, var(--color-neutral-50) 30%, var(--color-neutral-0))',
                     '--composer-radius': '1rem',
                     '--composer-padding': '8px',
                 } as React.CSSProperties
@@ -81,7 +84,7 @@ export const Thread: React.FC<IThreadProps> = (props) => {
                         </ThreadPrimitive.Messages>
                     </div>
 
-                    <ThreadPrimitive.ViewportFooter className="sticky bottom-0 flex flex-col gap-4 overflow-visible rounded-t-(--composer-radius) bg-neutral-0 pb-4 md:pb-6">
+                    <ThreadPrimitive.ViewportFooter className="sticky bottom-0 flex flex-col gap-3 overflow-visible rounded-t-(--composer-radius) bg-neutral-0 pb-4 md:pb-6">
                         <AuiIf
                             condition={(state) =>
                                 isNewChatView(state) && state.composer.isEmpty
@@ -90,6 +93,14 @@ export const Thread: React.FC<IThreadProps> = (props) => {
                             <ThreadSuggestions />
                         </AuiIf>
                         <Composer isOpen={isOpen} />
+                        {/* One quiet line under the composer: the way back to a filed request on a
+                            fresh chat, the way to a human once the conversation is under way. */}
+                        <AuiIf condition={isNewChatView}>
+                            <PastRequestsLink onViewRequests={onViewRequests} />
+                        </AuiIf>
+                        <AuiIf condition={(state) => !isNewChatView(state)}>
+                            <EmailEscalation />
+                        </AuiIf>
                     </ThreadPrimitive.ViewportFooter>
                 </div>
             </ThreadPrimitive.Viewport>
@@ -97,23 +108,120 @@ export const Thread: React.FC<IThreadProps> = (props) => {
     );
 };
 
+// Messages sent within the same sitting need no divider; a longer pause means the user comes back
+// to the conversation, and then the transcript says when it was left.
+const conversationGapMs = 30 * 60 * 1000;
+
+const timeFormatter = new Intl.DateTimeFormat('en-US', {
+    hour: '2-digit',
+    hour12: false,
+    minute: '2-digit',
+});
+
+const weekdayFormatter = new Intl.DateTimeFormat('en-US', { weekday: 'long' });
+
+const formatDividerLabel = (date: Date): string => {
+    const day =
+        date.toDateString() === new Date().toDateString()
+            ? chatCopy.thread.today
+            : weekdayFormatter.format(date);
+
+    return `${day} ${timeFormatter.format(date)}`;
+};
+
+const selectDividerLabel = (state: AssistantState): string | undefined => {
+    const { createdAt, index } = state.message;
+    const previous = state.thread.messages[index - 1];
+
+    if (
+        previous != null &&
+        createdAt.getTime() - previous.createdAt.getTime() < conversationGapMs
+    ) {
+        return undefined;
+    }
+
+    return formatDividerLabel(createdAt);
+};
+
+interface IThreadTimeDividerProps {
+    /**
+     * Time the messages below the divider start at.
+     */
+    label: string;
+}
+
+const ThreadTimeDivider: React.FC<IThreadTimeDividerProps> = (props) => {
+    const { label } = props;
+
+    return (
+        <div className="flex items-center gap-3">
+            <span className="h-px flex-1 bg-neutral-100" />
+            <p className="flex-none text-neutral-400 text-xs">{label}</p>
+            <span className="h-px flex-1 bg-neutral-100" />
+        </div>
+    );
+};
+
 const ThreadMessage: React.FC = () => {
     const role = useAuiState((state) => state.message.role);
+    const dividerLabel = useAuiState(selectDividerLabel);
 
-    return role === 'user' ? <UserMessage /> : <AssistantMessage />;
+    return (
+        <>
+            {dividerLabel != null && <ThreadTimeDivider label={dividerLabel} />}
+            {role === 'user' ? <UserMessage /> : <AssistantMessage />}
+        </>
+    );
 };
 
-// Fills the space between header and composer on a fresh chat: the greeting sits centered in it,
-// the request history (when any) right below.
+// Fills the space between header and composer on a fresh chat.
 const ThreadWelcome: React.FC = () => (
-    <div className="flex flex-1 flex-col items-center justify-center px-4 py-6 text-center">
-        <h2 className="max-w-md font-semibold text-2xl text-neutral-800">
+    <div className="flex flex-1 flex-col items-center justify-center px-8 py-6 text-center">
+        <Heading as="h2" className="text-balance" size="h3">
             {chatCopy.welcome.greeting}
-        </h2>
-        <ChatRequestHistory />
+        </Heading>
     </div>
 );
 
+interface IPastRequestsLinkProps {
+    /**
+     * Opens the requests filed from this device.
+     */
+    onViewRequests: () => void;
+}
+
+const PastRequestsLink: React.FC<IPastRequestsLinkProps> = (props) => {
+    const { onViewRequests } = props;
+
+    const requestHistory = useRequestHistory();
+
+    if (requestHistory.length === 0) {
+        return null;
+    }
+
+    return (
+        <button
+            className="focus-ring-primary mx-auto cursor-pointer rounded-sm text-neutral-500 text-xs underline underline-offset-2"
+            onClick={onViewRequests}
+            type="button"
+        >
+            {`${chatCopy.requestHistory.heading} (${requestHistory.length})`}
+        </button>
+    );
+};
+
+const EmailEscalation: React.FC = () => (
+    <p className="text-center text-neutral-400 text-xs">
+        {`${chatCopy.composer.escalationPrompt} `}
+        <a
+            className="text-primary-400 underline underline-offset-2"
+            href={supportEmailHref}
+        >
+            {chatCopy.composer.escalationLink}
+        </a>
+    </p>
+);
+
 const ThreadSuggestions: React.FC = () => (
     <div className="flex w-full flex-wrap items-center justify-center gap-2 px-4">
         {chatCopy.welcome.suggestions.map((suggestion) => (
@@ -124,7 +232,7 @@ const ThreadSuggestions: React.FC = () => (
                 send={true}
             >
                 <button
-                    className="focus-ring-primary whitespace-nowrap rounded-full border border-neutral-100 px-3.5 py-1.5 text-neutral-800 text-sm transition-colors hover:bg-neutral-50"
+                    className="focus-ring-primary cursor-pointer whitespace-nowrap rounded-full border border-neutral-100 px-3.5 py-1.5 text-neutral-800 text-sm transition-colors hover:bg-neutral-50"
                     type="button"
                 >
                     {suggestion.label}
@@ -146,6 +254,13 @@ const Composer: React.FC<IComposerProps> = (props) => {
 
     const inputRef = useRef<HTMLTextAreaElement>(null);
 
+    // A fresh chat asks for the issue, an ongoing one for the next reply.
+    const placeholder = useAuiState((state) =>
+        isNewChatView(state)
+            ? chatCopy.composer.placeholder
+            : chatCopy.composer.placeholderReply,
+    );
+
     // The host panel is non-modal (no focus trap), so the composer takes focus itself whenever
     // the chat becomes visible — including the very first lazy mount.
     useEffect(() => {
@@ -157,7 +272,7 @@ const Composer: React.FC<IComposerProps> = (props) => {
     return (
         <ComposerPrimitive.Root className="relative flex w-full flex-col">
             <ComposerPrimitive.AttachmentDropzone asChild={true}>
-                <div className="flex w-full flex-col gap-2 rounded-(--composer-radius) border border-neutral-100 bg-(--composer-bg) p-(--composer-padding) shadow-[0_4px_16px_-8px_rgba(0,0,0,0.08),0_1px_2px_rgba(0,0,0,0.04)] transition-[border-color,box-shadow] focus-within:border-primary-400 focus-within:shadow-[0_6px_24px_-8px_rgba(0,0,0,0.12),0_1px_2px_rgba(0,0,0,0.05)] data-[dragging=true]:border-primary-400 data-[dragging=true]:border-dashed data-[dragging=true]:bg-primary-50">
+                <div className="flex w-full flex-col gap-2 rounded-(--composer-radius) border border-neutral-200 bg-neutral-0 p-(--composer-padding) shadow-[0_4px_16px_-8px_rgba(0,0,0,0.08),0_1px_2px_rgba(0,0,0,0.04)] transition-[border-color,box-shadow] focus-within:border-primary-400 focus-within:shadow-[0_6px_24px_-8px_rgba(0,0,0,0.12),0_1px_2px_rgba(0,0,0,0.05)] data-[dragging=true]:border-primary-400 data-[dragging=true]:border-dashed data-[dragging=true]:bg-primary-50">
                     <ComposerAttachments />
                     <AuiIf
                         condition={(state) =>
@@ -172,7 +287,7 @@ const Composer: React.FC<IComposerProps> = (props) => {
                         aria-label={chatCopy.composer.inputLabel}
                         className="max-h-32 min-h-10 w-full resize-none bg-transparent px-2.5 py-1 text-neutral-800 text-sm caret-primary-400 outline-none placeholder:text-neutral-300"
                         enterKeyHint="send"
-                        placeholder={chatCopy.composer.placeholder}
+                        placeholder={placeholder}
                         ref={inputRef}
                         rows={1}
                     />
@@ -321,7 +436,7 @@ const AssistantMessage: React.FC = () => (
                     Text: MarkdownText,
                     Empty: AssistantTyping,
                     tools: {
-                        by_name: { createLinearTicket: CreateTicketCard },
+                        by_name: { [createTicketToolName]: CreateTicketCard },
                     },
                 }}
             />
@@ -344,7 +459,7 @@ const UserMessage: React.FC = () => (
         <UserMessageAttachments />
 
         <div className="relative col-start-2 min-w-0">
-            <div className="wrap-break-word whitespace-pre-wrap rounded-xl bg-neutral-100 px-4 py-2 text-neutral-800 text-sm empty:hidden">
+            <div className="wrap-break-word whitespace-pre-wrap rounded-xl rounded-br-sm bg-neutral-100 px-4 py-2 text-neutral-800 text-sm empty:hidden">
                 <MessagePrimitive.Parts />
             </div>
         </div>
diff --git a/packages/assistant-chat/src/components/tooltipIconButton/tooltipIconButton.tsx b/packages/assistant-chat/src/components/tooltipIconButton/tooltipIconButton.tsx
index 264c5f0011..da5bcc5a71 100644
--- a/packages/assistant-chat/src/components/tooltipIconButton/tooltipIconButton.tsx
+++ b/packages/assistant-chat/src/components/tooltipIconButton/tooltipIconButton.tsx
@@ -72,8 +72,9 @@ export const TooltipIconButton = forwardRef<
         ...rest
     } = props;
 
+    // Tailwind's reset gives buttons the default arrow cursor; every control in the app points.
     const classes = classNames(
-        'focus-ring-primary inline-flex shrink-0 items-center justify-center rounded-full outline-none transition-colors active:scale-90 disabled:pointer-events-none disabled:opacity-50',
+        'focus-ring-primary inline-flex shrink-0 cursor-pointer items-center justify-center rounded-full outline-none transition-colors active:scale-90 disabled:pointer-events-none disabled:opacity-50',
         variantClasses[variant],
         sizeClasses[size],
         className,
diff --git a/packages/assistant-chat/src/copy.ts b/packages/assistant-chat/src/copy.ts
index 3486fd5dfd..04fde1508e 100644
--- a/packages/assistant-chat/src/copy.ts
+++ b/packages/assistant-chat/src/copy.ts
@@ -1,7 +1,4 @@
-import {
-    assistantLimits,
-    type ITicketIntent,
-} from '@aragon/assistant-contracts';
+import { assistantLimits } from '@aragon/assistant-contracts';
 import type { FileRejectReason } from './files/fileValidation';
 
 // Single source of every user-facing string of the widget, grouped by component. Change wording
@@ -19,13 +16,16 @@ const maxFileSizeMb = Math.round(
 
 export const chatCopy = {
     header: {
-        title: 'Aragon Support Assistant',
-        close: 'Close',
+        title: 'Aragon Assistant',
+        collapse: 'Collapse chat',
+        back: 'Back to chat',
         startNewChat: 'Start new chat',
+        contextNew: 'New conversation',
+        // Rendered ahead of the drafted ticket title, e.g. "Draft: Voting page crashes".
+        contextDraftPrefix: 'Draft:',
     },
     welcome: {
-        greeting:
-            "Hi! Tell us what's going on and we'll get it to the right team.",
+        greeting: 'What do you need help with?',
         suggestions: [
             { label: 'Report a bug', message: "I'd like to report a bug." },
             {
@@ -38,21 +38,27 @@ export const chatCopy = {
     thread: {
         typing: 'Assistant is typing',
         copyMessage: 'Copy',
+        // Prefix of the time divider of messages sent today, e.g. "Today 14:26".
+        today: 'Today',
         chatErrorFallback:
             'Something went wrong. Please try sending your message again.',
         emailEscapeHatch: `…or email your request to ${supportEmail} →`,
     },
     composer: {
-        placeholder: 'Message…',
+        placeholder: 'Describe the issue…',
+        placeholderReply: 'Reply…',
         inputLabel: 'Message',
         send: 'Send message',
         stop: 'Stop generating',
         addAttachment: 'Add attachment',
         attachmentsShared: 'Attachments are shared with the support team.',
+        escalationPrompt: 'Prefer a human?',
+        escalationLink: 'Email support',
     },
     attachments: {
         remove: 'Remove file',
         previewTitle: 'Image attachment preview',
+        closePreview: 'Close preview',
         typeLabel: {
             image: 'Image',
             document: 'Document',
@@ -72,22 +78,17 @@ export const chatCopy = {
         string
     >,
     ticketCard: {
-        draftHeading: 'Review your request',
-        intentLabel: {
-            feedback: 'Feedback',
-            bug: 'Bug report',
-            support: 'Support request',
-        } satisfies Record<ITicketIntent, string>,
-        descriptionLabel: 'Details',
         stepsLabel: 'Steps to reproduce',
-        contactLabel: 'Contact',
+        // Rendered ahead of the contact the user left, e.g. "We'll reply to evan@aragon.org".
+        contactPrefix: "We'll reply to",
         preparing: 'Putting your request together…',
-        addMore: 'Anything to add? Any detail helps — just keep typing.',
-        create: 'Create',
+        addMore: 'Anything to add? Keep typing — this draft updates.',
+        create: 'Create ticket',
         dismiss: 'Dismiss',
         creating: 'Creating your request…',
         dismissed: 'Draft dismissed. Keep chatting to prepare a new one.',
-        superseded: 'This draft was set aside after your newer messages.',
+        superseded:
+            'Earlier draft set aside — your newer messages replaced it.',
         draftInterrupted:
             'That draft did not come through. Keep chatting to prepare a new one.',
         successTitle: 'Request created',
@@ -103,6 +104,7 @@ export const chatCopy = {
     },
     requestHistory: {
         heading: 'Past requests',
+        empty: 'No requests from this device yet.',
     },
     serviceErrors: {
         rateLimited:
diff --git a/packages/assistant-chat/src/requests/index.ts b/packages/assistant-chat/src/requests/index.ts
index 5dfd1d8fc4..e02b15a4fc 100644
--- a/packages/assistant-chat/src/requests/index.ts
+++ b/packages/assistant-chat/src/requests/index.ts
@@ -3,3 +3,4 @@ export {
     getRequestHistory,
     type IRequestHistoryEntry,
 } from './requestHistory';
+export { useRequestHistory } from './useRequestHistory';
diff --git a/packages/assistant-chat/src/requests/useRequestHistory.ts b/packages/assistant-chat/src/requests/useRequestHistory.ts
new file mode 100644
index 0000000000..ed7b9856c6
--- /dev/null
+++ b/packages/assistant-chat/src/requests/useRequestHistory.ts
@@ -0,0 +1,13 @@
+import { useState } from 'react';
+import { getRequestHistory, type IRequestHistoryEntry } from './requestHistory';
+
+/**
+ * Reads the device-local request history. A read per mount is enough: both places that show it
+ * (the link under the composer and the requests view) mount when the user enters them, which is
+ * always after a ticket has been filed.
+ */
+export const useRequestHistory = (): IRequestHistoryEntry[] => {
+    const [requestHistory] = useState(getRequestHistory);
+
+    return requestHistory;
+};
diff --git a/packages/assistant-chat/src/transport/createChatTransport.ts b/packages/assistant-chat/src/transport/createChatTransport.ts
index 0bb3c8597d..0028d74c43 100644
--- a/packages/assistant-chat/src/transport/createChatTransport.ts
+++ b/packages/assistant-chat/src/transport/createChatTransport.ts
@@ -1,4 +1,8 @@
-import type { IAppContext, IChatRequest } from '@aragon/assistant-contracts';
+import {
+    attachmentPartType,
+    type IAppContext,
+    type IChatRequest,
+} from '@aragon/assistant-contracts';
 import { DefaultChatTransport } from 'ai';
 import type { AssistantUIMessage } from './chatTransport.api';
 
@@ -17,10 +21,17 @@ export interface ICreateChatTransportParams {
     getAppContext: () => IAppContext;
 }
 
+// A file part carries the whole file inline as a data URL (the local transcript renders its
+// preview from it) and the service already holds the bytes for the ticket, so only the name
+// travels with the conversation — enough for the service to tell the model where an attachment
+// arrived, without pushing megabytes through every turn.
+const toRequestPart = (part: AssistantUIMessage['parts'][number]) =>
+    part.type === 'file'
+        ? { type: attachmentPartType, data: { filename: part.filename } }
+        : part;
+
 // The server re-validates against chatRequestSchema; only the fields of the contract are sent
-// (the default AI SDK body would leak chat id / trigger metadata). File parts exist only for the
-// local transcript preview — the server reads queued files from its own session store, so they
-// never travel with the conversation.
+// (the default AI SDK body would leak chat id / trigger metadata).
 const buildRequestBody = (
     params: ICreateChatTransportParams,
     messages: AssistantUIMessage[],
@@ -29,7 +40,7 @@ const buildRequestBody = (
     messages: messages.map((message) => ({
         id: message.id,
         role: message.role === 'user' ? 'user' : 'assistant',
-        parts: message.parts.filter((part) => part.type !== 'file'),
+        parts: message.parts.map(toRequestPart),
     })),
     appContext: params.getAppContext(),
 });
diff --git a/packages/assistant-contracts/src/file.ts b/packages/assistant-contracts/src/file.ts
index ef1bc1cbf0..6bcea2e420 100644
--- a/packages/assistant-contracts/src/file.ts
+++ b/packages/assistant-contracts/src/file.ts
@@ -5,6 +5,13 @@ import { z } from 'zod';
 // bodies — Vercel functions cap request bodies at 4.5 MB), then confirms the upload so the
 // service can validate the content and queue the file for the ticket.
 
+// The bytes of a queued file never travel with the conversation, but the model must see WHERE an
+// attachment arrived, so the message that carried it keeps a part naming the file. It rides as a
+// data part on purpose: an AI SDK service that does not know this part drops it, so the widget can
+// ship ahead of the service without breaking a turn that carries an attachment.
+// Shape: `{ type: 'data-attachment', data: { filename } }`.
+export const attachmentPartType = 'data-attachment';
+
 export const confirmFileRequestSchema = z.object({
     sessionId: z.uuid(),
     // URL returned by the blob client upload; the server only accepts URLs of its own store
diff --git a/packages/assistant-contracts/src/index.ts b/packages/assistant-contracts/src/index.ts
index 5f84b207c0..be08e15093 100644
--- a/packages/assistant-contracts/src/index.ts
+++ b/packages/assistant-contracts/src/index.ts
@@ -19,6 +19,7 @@ export {
     type IAssistantErrorCode,
 } from './error';
 export {
+    attachmentPartType,
     confirmFileRequestSchema,
     deleteFileRequestSchema,
     type IConfirmFileRequest,