@happyvertical/smrt-chat 0.51.5 → 0.51.6

package/dist/svelte/components/assistant/AssistantThreadList.svelte

@@ -0,0 +1,136 @@
+<script lang="ts">
+/**
+ * AssistantThreadList - sidebar list of assistant threads (#2904).
+ */
+import { useI18n } from '@happyvertical/smrt-ui/i18n';
+import { Button } from '@happyvertical/smrt-ui/ui';
+import { M } from '../../i18n.js';
+import type { AssistantThreadSummary } from './assistant-transport.js';
+
+const { t } = useI18n();
+
+export interface Props {
+  /** Threads to list, most-recent-first order left to the caller. */
+  threads: AssistantThreadSummary[];
+  /** The currently open thread id, highlighted and `aria-current`. */
+  activeThreadId?: string | null;
+  /** Fired with a thread's id when the user clicks its row. */
+  onselect: (threadId: string) => void;
+  /** Shown as a "+ New conversation" row when present; fired on click. */
+  oncreate?: () => void;
+}
+
+const { threads, activeThreadId = null, onselect, oncreate }: Props = $props();
+</script>
+
+<nav
+  class="assistant-thread-list"
+  aria-label={t(M['chat.assistant_thread_list.conversations_label'])}
+>
+  {#if oncreate}
+    <Button
+      type="button"
+      variant="ghost"
+      class="assistant-thread-list-new"
+      onclick={oncreate}
+    >
+      {t(M['chat.assistant_thread_list.new_conversation'])}
+    </Button>
+  {/if}
+  <ul>
+    {#each threads as thread (thread.id)}
+      <li>
+        <Button
+          type="button"
+          variant="ghost"
+          class={thread.id === activeThreadId
+            ? 'assistant-thread-list-item active'
+            : 'assistant-thread-list-item'}
+          onclick={() => onselect(thread.id)}
+          aria-current={thread.id === activeThreadId ? 'true' : undefined}
+        >
+          <span class="title">
+            {thread.title || t(M['chat.assistant_thread_list.untitled'])}
+          </span>
+          {#if thread.messageCount > 0}
+            <span class="count">{thread.messageCount}</span>
+          {/if}
+        </Button>
+      </li>
+    {/each}
+  </ul>
+</nav>
+
+<style>
+  .assistant-thread-list {
+    display: flex;
+    flex-direction: column;
+    border-right: 1px solid var(--smrt-color-outline-variant, #c4c6cf);
+    background: var(--smrt-color-surface-container-low, #f7f7fb);
+    min-width: 160px;
+    overflow-y: auto;
+  }
+
+  :global(.assistant-thread-list-new) {
+    margin: var(--smrt-spacing-2, 8px);
+    padding: var(--smrt-spacing-2, 8px) var(--smrt-spacing-3, 12px);
+    border: 1px dashed var(--smrt-color-outline-variant, #c4c6cf);
+    border-radius: var(--smrt-radius-medium, 8px);
+    background: transparent;
+    color: var(--smrt-color-primary, #005ac1);
+    font: var(--smrt-typography-label-medium-font, 500 0.8125rem/1.3 sans-serif);
+    cursor: pointer;
+    text-align: left;
+  }
+
+  :global(.assistant-thread-list-new:hover) {
+    background: var(--smrt-color-surface-container, #f0f0f4);
+  }
+
+  .assistant-thread-list ul {
+    list-style: none;
+    margin: 0;
+    padding: 0 var(--smrt-spacing-2, 8px) var(--smrt-spacing-2, 8px);
+    display: flex;
+    flex-direction: column;
+    gap: var(--smrt-spacing-1, 4px);
+  }
+
+  :global(.assistant-thread-list-item) {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    gap: var(--smrt-spacing-2, 8px);
+    width: 100%;
+    padding: var(--smrt-spacing-2, 8px) var(--smrt-spacing-3, 12px);
+    border: none;
+    border-radius: var(--smrt-radius-medium, 8px);
+    background: transparent;
+    color: var(--smrt-color-on-surface, #1a1c1e);
+    font: var(--smrt-typography-body-medium-font, 0.875rem/1.4 sans-serif);
+    text-align: left;
+    cursor: pointer;
+  }
+
+  :global(.assistant-thread-list-item:hover) {
+    background: var(--smrt-color-surface-container, #f0f0f4);
+  }
+
+  :global(.assistant-thread-list-item.active) {
+    background: var(--smrt-color-secondary-container, #d7e3f8);
+    color: var(--smrt-color-on-secondary-container, #0e1d31);
+    font-weight: var(--smrt-typography-weight-semibold, 600);
+  }
+
+  .title {
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+  }
+
+  .count {
+    flex-shrink: 0;
+    font: var(--smrt-typography-label-small-font, 500 0.6875rem/1 sans-serif);
+    color: var(--smrt-color-on-surface-variant, #43474e);
+  }
+</style>

package/dist/svelte/components/assistant/AssistantThreadList.svelte.d.ts

@@ -0,0 +1,15 @@
+import type { AssistantThreadSummary } from './assistant-transport.js';
+export interface Props {
+    /** Threads to list, most-recent-first order left to the caller. */
+    threads: AssistantThreadSummary[];
+    /** The currently open thread id, highlighted and `aria-current`. */
+    activeThreadId?: string | null;
+    /** Fired with a thread's id when the user clicks its row. */
+    onselect: (threadId: string) => void;
+    /** Shown as a "+ New conversation" row when present; fired on click. */
+    oncreate?: () => void;
+}
+declare const AssistantThreadList: import("svelte").Component<Props, {}, "">;
+type AssistantThreadList = ReturnType<typeof AssistantThreadList>;
+export default AssistantThreadList;
+//# sourceMappingURL=AssistantThreadList.svelte.d.ts.map

package/dist/svelte/components/assistant/AssistantThreadList.svelte.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AssistantThreadList.svelte.d.ts","sourceRoot":"","sources":["../../../../src/svelte/components/assistant/AssistantThreadList.svelte.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,0BAA0B,CAAC;AAGvE,MAAM,WAAW,KAAK;IACpB,mEAAmE;IACnE,OAAO,EAAE,sBAAsB,EAAE,CAAC;IAClC,oEAAoE;IACpE,cAAc,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/B,6DAA6D;IAC7D,QAAQ,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,CAAC;IACrC,wEAAwE;IACxE,QAAQ,CAAC,EAAE,MAAM,IAAI,CAAC;CACvB;AA0CD,QAAA,MAAM,mBAAmB,2CAAwC,CAAC;AAClE,KAAK,mBAAmB,GAAG,UAAU,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAClE,eAAe,mBAAmB,CAAC"}

package/dist/svelte/components/assistant/__tests__/AssistantComposer.test.js

@@ -0,0 +1,75 @@
+// @vitest-environment jsdom
+/**
+ * Component-level coverage for AssistantComposer (#2904 review finding 4).
+ *
+ * Before this fix, `handleSend` cleared `content`/`stagedAttachments`
+ * synchronously before `onsend`'s promise settled, so a transport failure
+ * discarded the user's typed message with no visible error.
+ */
+import { expectNoA11yViolations, render, screen, userEvent, } from '@happyvertical/smrt-vitest/svelte';
+import { describe, expect, it, vi } from 'vitest';
+import AssistantComposer from '../AssistantComposer.svelte';
+function fileInput(container) {
+    const input = container.querySelector('input[type="file"]');
+    if (!input)
+        throw new Error('file input not found');
+    return input;
+}
+const png = (name = 'photo.png') => new File(['data'], name, { type: 'image/png' });
+describe('AssistantComposer', () => {
+    it('keeps the draft and shows an inline error when onsend rejects', async () => {
+        const onsend = vi.fn().mockRejectedValue(new Error('network down'));
+        const onupload = vi.fn();
+        render(AssistantComposer, { props: { onsend, onupload } });
+        const textarea = screen.getByLabelText('Message');
+        await userEvent.type(textarea, 'hello there');
+        await userEvent.click(screen.getByRole('button', { name: 'Send' }));
+        expect(onsend).toHaveBeenCalledWith('hello there', []);
+        // The draft text must still be in the textarea — not cleared.
+        expect(textarea).toHaveValue('hello there');
+        expect(await screen.findByText(/Could not send: network down/i)).toBeInTheDocument();
+    });
+    it('clears the draft only after onsend resolves successfully', async () => {
+        const onsend = vi.fn().mockResolvedValue(undefined);
+        const onupload = vi.fn();
+        render(AssistantComposer, { props: { onsend, onupload } });
+        const textarea = screen.getByLabelText('Message');
+        await userEvent.type(textarea, 'hi');
+        await userEvent.click(screen.getByRole('button', { name: 'Send' }));
+        expect(onsend).toHaveBeenCalledWith('hi', []);
+        expect(textarea).toHaveValue('');
+        expect(screen.queryByText(/Could not send/i)).not.toBeInTheDocument();
+    });
+    // Cycle-2 third final: a rejecting onupload previously had no catch
+    // anywhere in handleFileChange, so the chip row never updated and no
+    // error appeared — the rejection escaped as an unhandled promise
+    // rejection from the DOM change event instead.
+    it('shows an inline error and keeps existing chips when onupload rejects', async () => {
+        const onsend = vi.fn();
+        const onupload = vi
+            .fn()
+            .mockResolvedValueOnce([{ id: 'att-1', name: 'existing.png' }])
+            .mockRejectedValueOnce(new Error('no writeEndpoint configured'));
+        const { container } = render(AssistantComposer, {
+            props: { onsend, onupload },
+        });
+        // First upload succeeds and stages a chip.
+        await userEvent.upload(fileInput(container), png('existing.png'));
+        expect(await screen.findByText('existing.png')).toBeInTheDocument();
+        // Second upload rejects: the existing chip must remain, and the
+        // rejection must show as an inline error.
+        await userEvent.upload(fileInput(container), png('second.png'));
+        expect(await screen.findByText(/Could not attach file: no writeEndpoint configured/i)).toBeInTheDocument();
+        expect(screen.getByText('existing.png')).toBeInTheDocument();
+        expect(screen.queryByText('second.png')).not.toBeInTheDocument();
+    });
+    // Cycle-3 second final finding 2: the hidden file input had no accessible
+    // name (the visually-hidden `clip: rect(0 0 0 0)` styling keeps it in the
+    // a11y tree, unlike ../shared/FileUpload.svelte's wrapping visible label).
+    it('is axe-clean', async () => {
+        const { container } = render(AssistantComposer, {
+            props: { onsend: vi.fn(), onupload: vi.fn() },
+        });
+        await expectNoA11yViolations(container);
+    });
+});

package/dist/svelte/components/assistant/__tests__/AssistantDock.test.js

@@ -0,0 +1,395 @@
+// @vitest-environment jsdom
+/**
+ * Component-level coverage for AssistantDock (#2904 review finding F1).
+ *
+ * The unit suite for `createAssistantDockController` and the smrt-svelte
+ * conformance-style integration test both drive a SEPARATE controller
+ * instance than the one the mounted component owns, so neither one could
+ * have caught F1: `AssistantDock`'s `$effect` read `$state` synchronously
+ * (via `startPolling` → `pendingSends`), so every real `send()` through the
+ * component's OWN controller re-ran the effect and its cleanup permanently
+ * unsubscribed the registry listener after the first message. This file
+ * renders the real component and drives it through its own DOM.
+ */
+import { createDataSurfaceRegistry, } from '@happyvertical/smrt-ui/data-surface';
+import { expectNoA11yViolations, render, screen, userEvent, } from '@happyvertical/smrt-vitest/svelte';
+import { describe, expect, it, vi } from 'vitest';
+import AssistantDock from '../AssistantDock.svelte';
+import { createInMemoryAssistantTransport } from '../assistant-transport.js';
+const identity = {
+    surfaceId: 'orders',
+    kind: 'table',
+    subject: { type: 'tenant', id: 'tenant-a' },
+};
+const descriptor = {
+    version: 1,
+    identity,
+    schemaVersion: 1,
+    label: 'Orders',
+    rowKey: 'id',
+    columns: [{ id: 'id', label: 'ID', capabilities: ['read'], role: 'row-key' }],
+    query: {
+        modes: ['rows'],
+        projectableColumnIds: ['id'],
+        searchableColumnIds: [],
+        filterableColumnIds: [],
+        sortableColumnIds: [],
+    },
+    actions: [],
+    controls: [],
+    limits: { maxQueryRows: 10, maxQueryBytes: 10_000, maxSelectionSize: 10 },
+};
+describe('AssistantDock (mounted component)', () => {
+    it('loadThreads/loadModels fire exactly once per mount, and the registry subscription survives a send (F1)', async () => {
+        const registry = createDataSurfaceRegistry();
+        const transport = createInMemoryAssistantTransport({
+            respond: (threadId, userMessage) => ({
+                id: 'assistant-1',
+                threadId,
+                content: `echo: ${userMessage.content}`,
+                role: 'assistant',
+                createdAt: new Date(),
+            }),
+        });
+        const listThreadsSpy = vi.spyOn(transport, 'listThreads');
+        render(AssistantDock, { props: { transport, registry } });
+        expect(await screen.findByText(/No data surfaces are mounted on this route/i)).toBeInTheDocument();
+        expect(listThreadsSpy).toHaveBeenCalledTimes(1);
+        // Create + open a thread through the UI, then send a real message
+        // through the component's OWN mounted controller.
+        await userEvent.click(screen.getByRole('button', { name: /New conversation/i }));
+        const textarea = await screen.findByLabelText('Message');
+        await userEvent.type(textarea, 'hello there');
+        const sendButton = screen.getByRole('button', { name: 'Send' });
+        await userEvent.click(sendButton);
+        expect(await screen.findByText('echo: hello there')).toBeInTheDocument();
+        // F1 regression: before the fix, the send above re-ran the mount effect
+        // and its cleanup permanently disposed the controller (unsubscribing
+        // the registry listener), so a surface registered afterward was never
+        // discovered and the "no surfaces" notice never cleared.
+        registry.register({
+            descriptor,
+            getSnapshot: () => ({ revision: 1, state: {} }),
+        });
+        // Poll until the notice clears (or fail): the registry event handler
+        // runs synchronously, so this should resolve on the very next microtask.
+        for (let attempt = 0; attempt < 20; attempt += 1) {
+            if (!screen.queryByText(/No data surfaces are mounted on this route/i)) {
+                break;
+            }
+            await new Promise((resolve) => setTimeout(resolve, 10));
+        }
+        expect(screen.queryByText(/No data surfaces are mounted on this route/i)).not.toBeInTheDocument();
+        // loadThreads must still have fired only once for the mount — not once
+        // per send/poll re-run of a re-triggered effect.
+        expect(listThreadsSpy).toHaveBeenCalledTimes(1);
+    });
+    // Finding B (#2904 review, third final pass): reassigning the `registry`
+    // prop (a host swapping tenant/workspace context) must be observed by the
+    // MOUNTED component's own controller, not just a freshly-constructed one.
+    // The corresponding controller-level test in
+    // create-assistant-dock-controller.test.ts asserts the harder-to-observe
+    // parts (surfaces content, previewAction rejection, preview invalidation)
+    // directly against syncRegistry(); this test proves the DOM-visible
+    // surfaces-empty notice reacts to the same prop swap through the real
+    // component, and that F1's "mount effect runs once" guarantee still
+    // holds afterward.
+    it('re-subscribes when the registry prop is reassigned to a different instance', async () => {
+        const r1 = createDataSurfaceRegistry();
+        r1.register({
+            descriptor,
+            getSnapshot: () => ({ revision: 1, state: {} }),
+        });
+        const transport = createInMemoryAssistantTransport();
+        const listThreadsSpy = vi.spyOn(transport, 'listThreads');
+        const { rerender } = render(AssistantDock, {
+            props: { transport, registry: r1 },
+        });
+        // R1 has a mounted surface — the empty notice must not show.
+        expect(screen.queryByText(/No data surfaces are mounted on this route/i)).not.toBeInTheDocument();
+        // Reassign the prop to a DIFFERENT, empty registry instance (R2).
+        const r2 = createDataSurfaceRegistry();
+        await rerender({ transport, registry: r2 });
+        expect(await screen.findByText(/No data surfaces are mounted on this route/i)).toBeInTheDocument();
+        // Registering a surface on R2 must be discovered — proves the
+        // subscription actually moved to R2, not just a one-time resync.
+        const r2Identity = { ...identity, surfaceId: 'products' };
+        r2.register({
+            descriptor: { ...descriptor, identity: r2Identity },
+            getSnapshot: () => ({ revision: 1, state: {} }),
+        });
+        for (let attempt = 0; attempt < 20; attempt += 1) {
+            if (!screen.queryByText(/No data surfaces are mounted on this route/i)) {
+                break;
+            }
+            await new Promise((resolve) => setTimeout(resolve, 10));
+        }
+        expect(screen.queryByText(/No data surfaces are mounted on this route/i)).not.toBeInTheDocument();
+        // F1 guarantee preserved: the registry-scoped effect must not have
+        // caused the SEPARATE mount effect to re-run — but Copilot PR #2919
+        // jAwsd's fix means the swap ITSELF now legitimately triggers exactly
+        // one more loadThreads() call, via syncRegistry()'s
+        // resetConversationStateForContextSwap() reloading from the new
+        // context. Two total: one from the mount effect, one from the swap.
+        expect(listThreadsSpy).toHaveBeenCalledTimes(2);
+    });
+    // Finding 1 (#2904 review, fresh cycle): the documented `surfaces` override
+    // prop did not exist on <AssistantDock> — only reachable by constructing
+    // the controller directly. Discovery half asserted here through the DOM:
+    // the override, not the registry's live contents, decides whether the
+    // "no surfaces" notice renders.
+    it("scopes discovery to the explicit `surfaces` override, ignoring the registry's live contents", async () => {
+        const registry = createDataSurfaceRegistry();
+        // Registry has ORDERS mounted, but the override is an explicit EMPTY
+        // list — the notice must still render "no surfaces" because the
+        // override, not the registry, is authoritative (surfaces is decoupled
+        // from what's actually registered once an override is set).
+        registry.register({
+            descriptor,
+            getSnapshot: () => ({ revision: 1, state: {} }),
+        });
+        const transport = createInMemoryAssistantTransport();
+        render(AssistantDock, {
+            props: { transport, registry, surfaces: [] },
+        });
+        expect(await screen.findByText(/No data surfaces are mounted on this route/i)).toBeInTheDocument();
+    });
+    // Copilot PR #2919 jAwr0: `surfaces` is a NARROWING filter over the live
+    // registry — an override identity that isn't genuinely registered must
+    // NOT make discovery non-empty (that broke the documented fail-closed
+    // route scoping). Renamed from "the `surfaces` override alone makes
+    // discovery non-empty, even with nothing registered", which asserted the
+    // now-fixed behavior.
+    it('the `surfaces` override does NOT make discovery non-empty when the override identity is not registered', async () => {
+        const registry = createDataSurfaceRegistry(); // nothing registered
+        const transport = createInMemoryAssistantTransport();
+        render(AssistantDock, {
+            props: { transport, registry, surfaces: [identity] },
+        });
+        expect(await screen.findByText(/No data surfaces are mounted on this route/i)).toBeInTheDocument();
+    });
+    it('the `surfaces` override makes discovery non-empty only when the identity IS also registered', async () => {
+        const registry = createDataSurfaceRegistry();
+        registry.register({
+            descriptor,
+            getSnapshot: () => ({ revision: 1, state: {} }),
+        });
+        const transport = createInMemoryAssistantTransport();
+        render(AssistantDock, {
+            props: { transport, registry, surfaces: [identity] },
+        });
+        expect(screen.queryByText(/No data surfaces are mounted on this route/i)).not.toBeInTheDocument();
+    });
+    // Finding 4 (#2904 review, fresh cycle): a failed mount-time listThreads
+    // must render as a dock-level error, not an empty, explanation-free
+    // thread list.
+    it('renders a dock-level error when the mount-time loadThreads() call rejects', async () => {
+        const registry = createDataSurfaceRegistry();
+        const transport = createInMemoryAssistantTransport();
+        transport.listThreads = async () => {
+            throw new Error('offline');
+        };
+        render(AssistantDock, { props: { transport, registry } });
+        expect(await screen.findByText(/Something went wrong: offline/i)).toBeInTheDocument();
+    });
+    // Cycle-2 second final finding 1: the `surfaces` override was captured
+    // once at construction — a mounted component's own controller never
+    // observed a reassignment of the prop. Drives it through the real
+    // component (rerender), not just the controller directly, mirroring how
+    // Finding B's registry-swap test complements the controller-level test.
+    it('re-scopes discovery and the action gate when the `surfaces` prop is reassigned, in both directions', async () => {
+        const registry = createDataSurfaceRegistry();
+        registry.register({
+            descriptor,
+            getSnapshot: () => ({ revision: 1, state: {} }),
+        });
+        const transport = createInMemoryAssistantTransport();
+        const productsIdentity = {
+            ...identity,
+            surfaceId: 'products',
+        };
+        // Copilot PR #2919 jAwr0: `surfaces` narrows against the live registry,
+        // so `products` must be genuinely registered too, or it would never
+        // pass the mount gate regardless of the override.
+        registry.register({
+            descriptor: { ...descriptor, identity: productsIdentity },
+            getSnapshot: () => ({ revision: 1, state: {} }),
+        });
+        const { rerender } = render(AssistantDock, {
+            props: { transport, registry, surfaces: [productsIdentity] },
+        });
+        // Override only includes `products`; the registered `orders` surface is
+        // gated out even though it's genuinely registered — the "no surfaces"
+        // notice must NOT show (the override list is non-empty).
+        expect(screen.queryByText(/No data surfaces are mounted on this route/i)).not.toBeInTheDocument();
+        // Narrow the override to an EMPTY list.
+        await rerender({ transport, registry, surfaces: [] });
+        expect(await screen.findByText(/No data surfaces are mounted on this route/i)).toBeInTheDocument();
+        // Widen back to include the registered `orders` surface — discovery
+        // must follow the reassignment and the notice must clear.
+        await rerender({ transport, registry, surfaces: [identity] });
+        for (let attempt = 0; attempt < 20; attempt += 1) {
+            if (!screen.queryByText(/No data surfaces are mounted on this route/i)) {
+                break;
+            }
+            await new Promise((resolve) => setTimeout(resolve, 10));
+        }
+        expect(screen.queryByText(/No data surfaces are mounted on this route/i)).not.toBeInTheDocument();
+    });
+    // Cycle-2 second final finding 1: the F1 "mount effect runs exactly once"
+    // guarantee must hold even with the new `surfaces`-scoped effect added
+    // alongside the existing `registry` one.
+    it('loadThreads still fires exactly once per mount when `surfaces` is reassigned', async () => {
+        const registry = createDataSurfaceRegistry();
+        const transport = createInMemoryAssistantTransport();
+        const listThreadsSpy = vi.spyOn(transport, 'listThreads');
+        const { rerender } = render(AssistantDock, {
+            props: { transport, registry, surfaces: [] },
+        });
+        await screen.findByText(/No data surfaces are mounted on this route/i);
+        await rerender({ transport, registry, surfaces: [identity] });
+        await rerender({ transport, registry, surfaces: [] });
+        expect(listThreadsSpy).toHaveBeenCalledTimes(1);
+    });
+    // Cycle-2 second final finding 2: "+ New conversation" and thread
+    // selection previously produced an unhandled rejection with zero
+    // user-visible surface when the transport failed — the exact path a
+    // `createSmrtAssistantTransport` without `writeEndpoint` is documented to
+    // hit.
+    it('a rejecting createThread (clicking "+ New conversation") shows the dock-level error banner', async () => {
+        const registry = createDataSurfaceRegistry();
+        const transport = createInMemoryAssistantTransport();
+        transport.createThread = async () => {
+            throw new Error('no writeEndpoint configured');
+        };
+        render(AssistantDock, { props: { transport, registry } });
+        await screen.findByText(/No data surfaces are mounted on this route/i);
+        await userEvent.click(screen.getByRole('button', { name: /New conversation/i }));
+        expect(await screen.findByText(/Something went wrong: no writeEndpoint configured/i)).toBeInTheDocument();
+    });
+    // Cycle-2 third final: a rejecting uploadAttachment previously had no
+    // catch in AssistantDock's handleUpload, so the dock-level banner never
+    // reflected an attachment failure the way it does for send/thread
+    // failures.
+    it('a rejecting uploadAttachment shows the dock-level error banner', async () => {
+        const registry = createDataSurfaceRegistry();
+        const transport = createInMemoryAssistantTransport();
+        transport.uploadAttachment = async () => {
+            throw new Error('no writeEndpoint configured');
+        };
+        const { container } = render(AssistantDock, {
+            props: { transport, registry },
+        });
+        await userEvent.click(screen.getByRole('button', { name: /New conversation/i }));
+        await screen.findByLabelText('Message');
+        const fileInput = container.querySelector('input[type="file"]');
+        if (!fileInput)
+            throw new Error('file input not found');
+        await userEvent.upload(fileInput, new File(['data'], 'photo.png', { type: 'image/png' }));
+        expect(await screen.findByText(/Something went wrong: no writeEndpoint configured/i)).toBeInTheDocument();
+    });
+    // Cycle-3 second final finding 1: message.attachments was populated by the
+    // transport but never rendered anywhere — an uploaded, sent attachment
+    // became permanently invisible the instant the composer's chip row
+    // cleared on success.
+    it('renders an attachment chip on a message after send()', async () => {
+        const registry = createDataSurfaceRegistry();
+        const transport = createInMemoryAssistantTransport();
+        const { container } = render(AssistantDock, {
+            props: { transport, registry },
+        });
+        await userEvent.click(screen.getByRole('button', { name: /New conversation/i }));
+        const textarea = await screen.findByLabelText('Message');
+        const fileInput = container.querySelector('input[type="file"]');
+        if (!fileInput)
+            throw new Error('file input not found');
+        await userEvent.upload(fileInput, new File(['data'], 'report.pdf', { type: 'application/pdf' }));
+        await userEvent.type(textarea, 'here is the report');
+        await userEvent.click(screen.getByRole('button', { name: 'Send' }));
+        expect(await screen.findByText('report.pdf')).toBeInTheDocument();
+    });
+    it('renders an attachment chip on a message loaded via loadMessages()', async () => {
+        const registry = createDataSurfaceRegistry();
+        const transport = createInMemoryAssistantTransport();
+        const originalLoadMessages = transport.loadMessages.bind(transport);
+        transport.loadMessages = async (threadId) => {
+            const existing = await originalLoadMessages(threadId);
+            if (existing.length > 0)
+                return existing;
+            return [
+                {
+                    id: 'seeded-1',
+                    threadId,
+                    content: 'attached earlier',
+                    role: 'user',
+                    createdAt: new Date(),
+                    attachments: [{ id: 'att-seeded', name: 'contract.docx' }],
+                },
+            ];
+        };
+        render(AssistantDock, { props: { transport, registry } });
+        await userEvent.click(screen.getByRole('button', { name: /New conversation/i }));
+        expect(await screen.findByText('contract.docx')).toBeInTheDocument();
+    });
+    // Cycle-3 second final finding 2: a `models`-bearing transport mounts
+    // ModelPicker (previously untested and unnamed anywhere in this suite);
+    // an attachment-bearing message exercises the chip/link list added for
+    // finding 1 above. Neither path had ever been axe-checked.
+    it('is axe-clean with ModelPicker mounted and an attachment-bearing message', async () => {
+        const registry = createDataSurfaceRegistry();
+        const transport = createInMemoryAssistantTransport({
+            models: [
+                { id: 'model-a', label: 'Model A' },
+                { id: 'model-b', label: 'Model B' },
+            ],
+        });
+        const { container } = render(AssistantDock, {
+            props: { transport, registry },
+        });
+        await userEvent.click(screen.getByRole('button', { name: /New conversation/i }));
+        const textarea = await screen.findByLabelText('Message');
+        const fileInput = container.querySelector('input[type="file"]');
+        if (!fileInput)
+            throw new Error('file input not found');
+        await userEvent.upload(fileInput, new File(['data'], 'report.pdf', { type: 'application/pdf' }));
+        await userEvent.type(textarea, 'here is the report');
+        await userEvent.click(screen.getByRole('button', { name: 'Send' }));
+        await screen.findByText('report.pdf');
+        // ModelPicker must have mounted (its accessible name resolves).
+        expect(screen.getByLabelText('Model')).toBeInTheDocument();
+        await expectNoA11yViolations(container);
+    });
+    // Cycle-3 second final F1 addendum: attachment.url is transport-supplied
+    // data bound to <a href> — a javascript: URL must never render a
+    // clickable anchor.
+    it('renders a javascript: attachment URL as plain text, not an anchor', async () => {
+        const registry = createDataSurfaceRegistry();
+        const transport = createInMemoryAssistantTransport();
+        const originalLoadMessages = transport.loadMessages.bind(transport);
+        transport.loadMessages = async (threadId) => {
+            const existing = await originalLoadMessages(threadId);
+            if (existing.length > 0)
+                return existing;
+            return [
+                {
+                    id: 'seeded-xss',
+                    threadId,
+                    content: 'attached earlier',
+                    role: 'user',
+                    createdAt: new Date(),
+                    attachments: [
+                        {
+                            id: 'att-xss',
+                            name: 'evil.txt',
+                            url: 'javascript:alert(1)',
+                        },
+                    ],
+                },
+            ];
+        };
+        render(AssistantDock, { props: { transport, registry } });
+        await userEvent.click(screen.getByRole('button', { name: /New conversation/i }));
+        const attachmentText = await screen.findByText('evil.txt');
+        expect(attachmentText.closest('a')).toBeNull();
+    });
+});

package/dist/svelte/components/assistant/__tests__/AssistantThreadList.test.js

@@ -0,0 +1,45 @@
+// @vitest-environment jsdom
+/**
+ * Component-level coverage for AssistantThreadList (#2904 review, cycle-3
+ * second final F2 — none of the three new assistant components carried an
+ * axe assertion; this one had no test file at all).
+ */
+import { expectNoA11yViolations, render, screen, userEvent, } from '@happyvertical/smrt-vitest/svelte';
+import { describe, expect, it, vi } from 'vitest';
+import AssistantThreadList from '../AssistantThreadList.svelte';
+const threads = [
+    { id: 't1', title: 'Order question', isResolved: false, messageCount: 3 },
+    { id: 't2', title: '', isResolved: false, messageCount: 0 },
+];
+describe('AssistantThreadList', () => {
+    it('renders each thread and fires onselect with its id', async () => {
+        const onselect = vi.fn();
+        render(AssistantThreadList, {
+            props: { threads, activeThreadId: 't1', onselect },
+        });
+        expect(screen.getByText('Order question')).toBeInTheDocument();
+        // Untitled fallback for a thread with an empty title.
+        expect(screen.getByText('Untitled')).toBeInTheDocument();
+        await userEvent.click(screen.getByText('Untitled'));
+        expect(onselect).toHaveBeenCalledWith('t2');
+    });
+    it('renders a "New conversation" row and fires oncreate when supplied', async () => {
+        const oncreate = vi.fn();
+        render(AssistantThreadList, {
+            props: { threads: [], onselect: vi.fn(), oncreate },
+        });
+        await userEvent.click(screen.getByRole('button', { name: /New conversation/i }));
+        expect(oncreate).toHaveBeenCalledOnce();
+    });
+    it('is axe-clean', async () => {
+        const { container } = render(AssistantThreadList, {
+            props: {
+                threads,
+                activeThreadId: 't1',
+                onselect: vi.fn(),
+                oncreate: vi.fn(),
+            },
+        });
+        await expectNoA11yViolations(container);
+    });
+});