From f18a93ac34949500c3f2b97b199a2105abc5c8a6 Mon Sep 17 00:00:00 2001
From: Andrew <ilin.andrii@gmail.com>
Date: Wed, 5 Aug 2026 20:03:45 +0200
Subject: [PATCH] feat(APP-1004): iterate the support assistant on design
 feedback
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The panel header carries the Aragon mark and a live subline naming 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 out of the greeting into a view of
their own, reached from a link under the composer, where the mail escape
hatch now lives as a footnote. The transcript opens with a time divider,
and the navigation trigger withdraws while the panel is open — the panel
collapses through its own chevron, which hands focus back to the trigger
taking its place.

The header carries the exact height of the navigation bar so their bottom
borders meet in a line rather than a step, and every control in the widget
points at the cursor again.

Two conversations were also broken. Every stream is now opened against the
incoming history, so an approval resume continues the assistant message the
draft lives in instead of opening a second one — the widget seeds its
response from the last message, so a fresh id made it append a copy, and the
sentence written before the tool call appeared again under the created
ticket. And an attachment reaches the model as a line inside the message that
carried it, 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. The name travels as a data part, which a service that does not know it
drops, so the widget can ship ahead of the assistant.
---
 ...pp-1004-assistant-chat-design-iteration.md |   6 +
 .changeset/app-1004-assistant-chat-polish.md  |   5 +
 ...p-1004-assistant-resume-and-attachments.md |   6 +
 .../smoke/supportChat/supportChat.spec.ts     |  34 ++--
 apps/app/src/assets/locales/en.json           |   1 -
 .../components/supportChat/supportChat.tsx    |   2 +-
 .../supportChat/supportChatTrigger.test.tsx   |  30 ++--
 .../supportChat/supportChatTrigger.tsx        |  37 +++--
 .../assistant/src/chat/prompts/agentPrompt.ts |  21 ++-
 apps/assistant/src/routes/chat.test.ts        |  61 +++++++
 apps/assistant/src/routes/chat.ts             |  68 ++++++--
 .../assistantChat/assistantChat.test.tsx      | 142 ++++++++++++++--
 .../assistantChat/assistantChat.tsx           |  32 +++-
 .../src/components/attachment/attachment.tsx  |   2 +-
 .../src/components/chatHeader/aragonMark.tsx  |  22 +++
 .../src/components/chatHeader/chatHeader.tsx  | 137 ++++++++++++----
 .../chatRequestHistory/chatRequestHistory.tsx |  33 ++--
 .../createTicketCard/createTicketCard.tsx     |  91 ++++-------
 .../src/components/thread/thread.tsx          | 151 +++++++++++++++---
 .../tooltipIconButton/tooltipIconButton.tsx   |   3 +-
 packages/assistant-chat/src/copy.ts           |  42 ++---
 packages/assistant-chat/src/requests/index.ts |   1 +
 .../src/requests/useRequestHistory.ts         |  13 ++
 .../src/transport/createChatTransport.ts      |  21 ++-
 packages/assistant-contracts/src/file.ts      |   7 +
 packages/assistant-contracts/src/index.ts     |   1 +
 26 files changed, 741 insertions(+), 228 deletions(-)
 create mode 100644 .changeset/app-1004-assistant-chat-design-iteration.md
 create mode 100644 .changeset/app-1004-assistant-chat-polish.md
 create mode 100644 .changeset/app-1004-assistant-resume-and-attachments.md
 create mode 100644 packages/assistant-chat/src/components/chatHeader/aragonMark.tsx
 create mode 100644 packages/assistant-chat/src/requests/useRequestHistory.ts

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,