@happyvertical/smrt-chat 0.51.10 → 0.51.11

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

@@ -13,9 +13,10 @@
  */
 import { createDataSurfaceRegistry, } from '@happyvertical/smrt-ui/data-surface';
 import { expectNoA11yViolations, render, screen, userEvent, } from '@happyvertical/smrt-vitest/svelte';
+import { createRawSnippet } from 'svelte';
 import { describe, expect, it, vi } from 'vitest';
 import AssistantDock from '../AssistantDock.svelte';
-import { createInMemoryAssistantTransport } from '../assistant-transport.js';
+import { createInMemoryAssistantTransport, } from '../assistant-transport.js';
 const identity = {
     surfaceId: 'orders',
     kind: 'table',
@@ -392,4 +393,123 @@ describe('AssistantDock (mounted component)', () => {
         const attachmentText = await screen.findByText('evil.txt');
         expect(attachmentText.closest('a')).toBeNull();
     });
+    // #3000: in a narrow container the thread list collapses behind a
+    // "Conversations" disclosure (the `@container` rule decides visibility;
+    // jsdom has no layout, so this pins the state + ARIA contract the CSS
+    // keys off). Widths are measured in a real browser, see the PR.
+    it('exposes a labelled Conversations disclosure that controls the thread list and closes when a conversation starts (#3000)', async () => {
+        const registry = createDataSurfaceRegistry();
+        const transport = createInMemoryAssistantTransport();
+        const { container } = render(AssistantDock, {
+            props: { transport, registry },
+        });
+        const toggle = screen.getByRole('button', { name: 'Conversations' });
+        expect(toggle).toHaveAttribute('aria-expanded', 'false');
+        const controlsId = toggle.getAttribute('aria-controls');
+        expect(controlsId).toBeTruthy();
+        const region = container.querySelector(`#${CSS.escape(controlsId ?? '')}`);
+        expect(region).not.toBeNull();
+        expect(region?.querySelector('nav[aria-label="Assistant conversations"]')).not.toBeNull();
+        const layout = container.querySelector('.assistant-dock-layout');
+        expect(layout).not.toHaveAttribute('data-threads-open');
+        await userEvent.click(toggle);
+        expect(toggle).toHaveAttribute('aria-expanded', 'true');
+        expect(layout).toHaveAttribute('data-threads-open');
+        toggle.focus();
+        await userEvent.keyboard('{Enter}');
+        expect(toggle).toHaveAttribute('aria-expanded', 'false');
+        await userEvent.keyboard(' ');
+        expect(toggle).toHaveAttribute('aria-expanded', 'true');
+        // Starting a conversation from the open list hands the width back.
+        await userEvent.click(screen.getByRole('button', { name: /New conversation/i }));
+        expect(toggle).toHaveAttribute('aria-expanded', 'false');
+        expect(layout).not.toHaveAttribute('data-threads-open');
+        // The activated button is now inside a hidden region; focus returns to
+        // the toggle instead of falling back to <body>.
+        await vi.waitFor(() => expect(document.activeElement).toBe(toggle));
+        await expectNoA11yViolations(container);
+    });
+    it('closes the narrow list and returns focus to the toggle when an existing thread is selected (#3000)', async () => {
+        const registry = createDataSurfaceRegistry();
+        const transport = createInMemoryAssistantTransport();
+        await transport.createThread('Existing chat');
+        render(AssistantDock, { props: { transport, registry } });
+        const toggle = screen.getByRole('button', { name: 'Conversations' });
+        await userEvent.click(toggle);
+        expect(toggle).toHaveAttribute('aria-expanded', 'true');
+        await userEvent.click(await screen.findByRole('button', { name: /Existing chat/ }));
+        expect(toggle).toHaveAttribute('aria-expanded', 'false');
+        await vi.waitFor(() => expect(document.activeElement).toBe(toggle));
+    });
+    // #2988: a host renders a message's own toolCallData through the
+    // `toolCall` snippet; without one the dock never renders the payload.
+    describe('toolCall snippet (#2988)', () => {
+        const hostile = '<img src=x onerror="window.__pwned=1">';
+        function transportWithToolCall() {
+            return createInMemoryAssistantTransport({
+                respond: (threadId, userMessage) => ({
+                    id: `assistant-${userMessage.id}`,
+                    threadId,
+                    content: userMessage.content === 'plain' ? 'no tool' : 'with tool',
+                    role: 'assistant',
+                    createdAt: new Date(),
+                    toolCallData: userMessage.content === 'plain'
+                        ? undefined
+                        : { kind: 'imageEditCandidate', label: hostile },
+                }),
+            });
+        }
+        async function sendThroughDock(text) {
+            const textarea = await screen.findByLabelText('Message');
+            await userEvent.type(textarea, text);
+            await userEvent.click(screen.getByRole('button', { name: 'Send' }));
+        }
+        it('renders the host snippet inside the bubble only for messages with toolCallData', async () => {
+            const seen = [];
+            const toolCall = createRawSnippet((message) => ({
+                render: () => '<span class="host-tool-call"></span>',
+                setup(node) {
+                    const m = message();
+                    seen.push(m);
+                    const data = m.toolCallData;
+                    node.textContent = `${data.kind}: ${data.label}`;
+                },
+            }));
+            const { container } = render(AssistantDock, {
+                props: {
+                    transport: transportWithToolCall(),
+                    registry: createDataSurfaceRegistry(),
+                    toolCall,
+                },
+            });
+            await userEvent.click(screen.getByRole('button', { name: /New conversation/i }));
+            await sendThroughDock('plain');
+            expect(await screen.findByText('no tool')).toBeInTheDocument();
+            await sendThroughDock('tool');
+            expect(await screen.findByText('with tool')).toBeInTheDocument();
+            const regions = container.querySelectorAll('.assistant-dock-tool-call');
+            expect(regions).toHaveLength(1);
+            expect(regions[0].textContent).toBe(`imageEditCandidate: ${hostile}`);
+            // Rendered as text, never parsed as markup.
+            expect(container.querySelector('img')).toBeNull();
+            expect(regions[0]
+                .closest('li')
+                ?.querySelector('.assistant-dock-message-content')?.textContent).toBe('with tool');
+            expect(seen.every((m) => m.toolCallData != null)).toBe(true);
+        });
+        it('renders no tool-call region and never the raw payload without a snippet', async () => {
+            const { container } = render(AssistantDock, {
+                props: {
+                    transport: transportWithToolCall(),
+                    registry: createDataSurfaceRegistry(),
+                },
+            });
+            await userEvent.click(screen.getByRole('button', { name: /New conversation/i }));
+            await sendThroughDock('tool');
+            expect(await screen.findByText('with tool')).toBeInTheDocument();
+            expect(container.querySelector('.assistant-dock-tool-call')).toBeNull();
+            expect(container.innerHTML).not.toContain('imageEditCandidate');
+            expect(container.querySelector('img')).toBeNull();
+        });
+    });
 });

package/dist/svelte/components/assistant/__tests__/assistant-dock-action-outcome.test.js

@@ -0,0 +1,320 @@
+// @vitest-environment jsdom
+/**
+ * #2990: an apply that reached no server decision ("unknown outcome") is kept
+ * apart from a refusal, keeps its idempotency key, and can only be retried
+ * with that same key — never discarded or re-proposed under a fresh one.
+ *
+ * `idempotentServer` models the server adapter's contract: the first apply
+ * for a key commits and records its result; any later apply with the same
+ * key replays that result without committing again, and a different key is
+ * a new mutation. `commits` is the double-apply oracle.
+ */
+import { createDataSurfaceRegistry, } from '@happyvertical/smrt-ui/data-surface';
+import { 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';
+import { ASSISTANT_ACTION_UNKNOWN_OUTCOME_REASONS, createAssistantDockController, } from '../create-assistant-dock-controller.svelte.js';
+const identity = {
+    surfaceId: 'orders',
+    kind: 'table',
+    subject: { type: 'tenant', id: 'tenant-a' },
+};
+function registryWithSurface() {
+    const registry = createDataSurfaceRegistry();
+    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 },
+    };
+    registry.register({
+        descriptor,
+        getSnapshot: () => ({ revision: 1, state: {} }),
+    });
+    return registry;
+}
+const REQUEST_ID = 'req-ship';
+function proposal() {
+    return {
+        version: 1,
+        requestId: REQUEST_ID,
+        identity,
+        actionId: 'ship',
+        phase: 'preview',
+        selection: { scope: 'explicit-ids', rowIds: ['order-1'] },
+    };
+}
+function result(request, phase, ok, reason) {
+    return {
+        version: 1,
+        requestId: request.requestId,
+        identity: request.identity,
+        actionId: request.actionId,
+        phase,
+        ok,
+        ...(reason ? { reason } : {}),
+    };
+}
+function idempotentServer() {
+    const byKey = new Map();
+    const server = {
+        commits: 0,
+        applyCalls: 0,
+        keys: [],
+        mode: 'commit',
+        gate: undefined,
+        preview: vi.fn(async (request) => result(request, 'preview', true)),
+        client: undefined,
+    };
+    server.client = {
+        preview: server.preview,
+        apply: async (request, key) => {
+            server.applyCalls += 1;
+            server.keys.push(key);
+            if (server.gate)
+                await server.gate;
+            const replay = byKey.get(key);
+            if (replay)
+                return replay;
+            if (server.mode === 'in-progress') {
+                return result(request, 'apply', false, 'idempotency_in_progress');
+            }
+            server.commits += 1;
+            const applied = result(request, 'apply', true);
+            byKey.set(key, applied);
+            if (server.mode === 'commit-then-lose-response') {
+                throw new Error('network: response lost');
+            }
+            return applied;
+        },
+    };
+    return server;
+}
+function setup(server = idempotentServer()) {
+    const onActionApplied = vi.fn();
+    const controller = createAssistantDockController({
+        transport: createInMemoryAssistantTransport(),
+        registry: registryWithSurface(),
+        actionClient: server.client,
+        onActionApplied,
+    });
+    return { controller, server, onActionApplied };
+}
+async function previewed(controller) {
+    await controller.previewAction(proposal());
+    expect(controller.actions.get(REQUEST_ID)?.status).toBe('previewed');
+    return controller.actions.get(REQUEST_ID)?.idempotencyKey;
+}
+describe('unknown apply outcome vs refusal (#2990)', () => {
+    it('marks a rejected apply (transport failure) as an unknown outcome and keeps its key', async () => {
+        const { controller, server } = setup();
+        const key = await previewed(controller);
+        server.mode = 'commit-then-lose-response';
+        await controller.applyAction(REQUEST_ID);
+        const state = controller.actions.get(REQUEST_ID);
+        expect(state?.status).toBe('failed');
+        expect(state?.outcomeUnknown).toBe(true);
+        expect(state?.retryable).toBe(true);
+        expect(state?.idempotencyKey).toBe(key);
+        controller.dispose();
+    });
+    it.each(ASSISTANT_ACTION_UNKNOWN_OUTCOME_REASONS)('treats ok:false with reason %s as an unknown outcome', async (reason) => {
+        const controller = createAssistantDockController({
+            transport: createInMemoryAssistantTransport(),
+            registry: registryWithSurface(),
+            actionClient: {
+                preview: async (request) => result(request, 'preview', true),
+                apply: async (request) => result(request, 'apply', false, reason),
+            },
+        });
+        await previewed(controller);
+        await controller.applyAction(REQUEST_ID);
+        expect(controller.actions.get(REQUEST_ID)?.outcomeUnknown).toBe(true);
+        controller.dispose();
+    });
+    it.each([
+        'denied',
+        'not_found',
+        'idempotency_conflict',
+        'stale_revision',
+        'confirmation_required',
+        'confirmation_mismatch',
+    ])('treats ok:false with reason %s as a refusal', async (reason) => {
+        const controller = createAssistantDockController({
+            transport: createInMemoryAssistantTransport(),
+            registry: registryWithSurface(),
+            actionClient: {
+                preview: async (request) => result(request, 'preview', true),
+                apply: async (request) => result(request, 'apply', false, reason),
+            },
+        });
+        await previewed(controller);
+        await controller.applyAction(REQUEST_ID);
+        const state = controller.actions.get(REQUEST_ID);
+        expect(state?.status).toBe('failed');
+        expect(state?.outcomeUnknown).toBe(false);
+        // A refusal is terminal, so discarding it is allowed.
+        controller.rejectAction(REQUEST_ID);
+        expect(controller.actions.has(REQUEST_ID)).toBe(false);
+        controller.dispose();
+    });
+});
+describe('an unknown outcome cannot be discarded or re-keyed (#2990)', () => {
+    it('refuses rejectAction and keeps the entry and key', async () => {
+        const { controller, server } = setup();
+        const key = await previewed(controller);
+        server.mode = 'commit-then-lose-response';
+        await controller.applyAction(REQUEST_ID);
+        controller.rejectAction(REQUEST_ID);
+        expect(controller.actions.get(REQUEST_ID)?.idempotencyKey).toBe(key);
+        expect(controller.actions.get(REQUEST_ID)?.outcomeUnknown).toBe(true);
+        expect(controller.error).toMatch(/rejectAction refused/);
+        controller.dispose();
+    });
+    it('refuses a new previewAction for the same request id', async () => {
+        const { controller, server } = setup();
+        const key = await previewed(controller);
+        server.mode = 'commit-then-lose-response';
+        await controller.applyAction(REQUEST_ID);
+        server.preview.mockClear();
+        await controller.previewAction(proposal());
+        expect(server.preview).not.toHaveBeenCalled();
+        expect(controller.actions.get(REQUEST_ID)?.idempotencyKey).toBe(key);
+        expect(controller.actions.get(REQUEST_ID)?.outcomeUnknown).toBe(true);
+        expect(controller.error).toMatch(/previewAction refused/);
+        controller.dispose();
+    });
+    it('refuses a new previewAction while an apply is in flight', async () => {
+        const { controller, server } = setup();
+        const key = await previewed(controller);
+        let release;
+        server.gate = new Promise((resolve) => {
+            release = resolve;
+        });
+        const applying = controller.applyAction(REQUEST_ID);
+        await controller.previewAction(proposal());
+        expect(controller.actions.get(REQUEST_ID)?.status).toBe('applying');
+        expect(controller.actions.get(REQUEST_ID)?.idempotencyKey).toBe(key);
+        release();
+        await applying;
+        expect(controller.actions.get(REQUEST_ID)?.status).toBe('applied');
+        expect(server.commits).toBe(1);
+        controller.dispose();
+    });
+});
+describe('same-key retry after an unknown outcome (#2990)', () => {
+    it('replays with the same key, applies exactly once, and clears the flag', async () => {
+        const { controller, server, onActionApplied } = setup();
+        const key = await previewed(controller);
+        server.mode = 'commit-then-lose-response';
+        await controller.applyAction(REQUEST_ID);
+        expect(server.commits).toBe(1);
+        // The operator tries every discard/re-propose path, then retries.
+        controller.rejectAction(REQUEST_ID);
+        await controller.previewAction(proposal());
+        server.mode = 'commit';
+        await controller.applyAction(REQUEST_ID);
+        const state = controller.actions.get(REQUEST_ID);
+        expect(state?.status).toBe('applied');
+        expect(state?.outcomeUnknown).toBe(false);
+        expect(server.keys).toEqual([key, key]);
+        expect(server.commits).toBe(1);
+        expect(onActionApplied).toHaveBeenCalledTimes(1);
+        controller.dispose();
+    });
+    it('keeps the key through idempotency_in_progress until the first attempt settles', async () => {
+        const { controller, server } = setup();
+        const key = await previewed(controller);
+        server.mode = 'in-progress';
+        await controller.applyAction(REQUEST_ID);
+        await controller.applyAction(REQUEST_ID);
+        expect(controller.actions.get(REQUEST_ID)?.outcomeUnknown).toBe(true);
+        server.mode = 'commit';
+        await controller.applyAction(REQUEST_ID);
+        expect(controller.actions.get(REQUEST_ID)?.status).toBe('applied');
+        expect(new Set(server.keys)).toEqual(new Set([key]));
+        expect(server.commits).toBe(1);
+        controller.dispose();
+    });
+    it('coalesces concurrent duplicate retries into one in-flight apply', async () => {
+        const { controller, server } = setup();
+        const key = await previewed(controller);
+        server.mode = 'commit-then-lose-response';
+        await controller.applyAction(REQUEST_ID);
+        server.mode = 'commit';
+        let release;
+        server.gate = new Promise((resolve) => {
+            release = resolve;
+        });
+        const callsBefore = server.applyCalls;
+        const retries = [
+            controller.applyAction(REQUEST_ID),
+            controller.applyAction(REQUEST_ID),
+            controller.applyAction(REQUEST_ID),
+        ];
+        controller.rejectAction(REQUEST_ID);
+        release();
+        await Promise.all(retries);
+        expect(server.applyCalls - callsBefore).toBe(1);
+        expect(server.keys.every((k) => k === key)).toBe(true);
+        expect(server.commits).toBe(1);
+        expect(controller.actions.get(REQUEST_ID)?.status).toBe('applied');
+        controller.dispose();
+    });
+    it('refuses a duplicate retry once the action is applied', async () => {
+        const { controller, server } = setup();
+        await previewed(controller);
+        server.mode = 'commit-then-lose-response';
+        await controller.applyAction(REQUEST_ID);
+        server.mode = 'commit';
+        await controller.applyAction(REQUEST_ID);
+        const calls = server.applyCalls;
+        await controller.applyAction(REQUEST_ID);
+        expect(server.applyCalls).toBe(calls);
+        expect(server.commits).toBe(1);
+        controller.dispose();
+    });
+});
+describe('AssistantDock unknown-outcome affordance (#2990)', () => {
+    it('withdraws Reject and offers a same-key Check again', async () => {
+        const server = idempotentServer();
+        let dock;
+        render(AssistantDock, {
+            props: {
+                transport: createInMemoryAssistantTransport(),
+                registry: registryWithSurface(),
+                actionClient: server.client,
+                oncontroller: (c) => {
+                    dock = c;
+                },
+            },
+        });
+        await dock?.previewAction(proposal());
+        server.mode = 'commit-then-lose-response';
+        await userEvent.click(await screen.findByRole('button', { name: 'Confirm' }));
+        const check = await screen.findByRole('button', { name: 'Check again' });
+        expect(screen.getByRole('status')).toHaveTextContent(/couldn't confirm whether this change was applied/);
+        expect(screen.queryByRole('button', { name: 'Reject' })).toBeNull();
+        expect(screen.queryByRole('button', { name: 'Confirm' })).toBeNull();
+        server.mode = 'commit';
+        await userEvent.click(check);
+        await vi.waitFor(() => expect(screen.queryByRole('button', { name: 'Check again' })).toBeNull());
+        expect(dock?.actions.get(REQUEST_ID)?.status).toBe('applied');
+        expect(server.commits).toBe(1);
+    });
+});

package/dist/svelte/components/assistant/__tests__/assistant-dock-host-actions.test.js

@@ -0,0 +1,185 @@
+// @vitest-environment jsdom
+/**
+ * #2989: a host can propose an action into the dock and observe an applied
+ * outcome — controller `onActionApplied`, and AssistantDock's
+ * `oncontroller` / `onactionapplied` props.
+ */
+import { createDataSurfaceRegistry, } from '@happyvertical/smrt-ui/data-surface';
+import { 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';
+import { createAssistantDockController, } from '../create-assistant-dock-controller.svelte.js';
+const identity = {
+    surfaceId: 'assets',
+    kind: 'table',
+    subject: { type: 'tenant', id: 'tenant-a' },
+};
+function registryWithSurface() {
+    const registry = createDataSurfaceRegistry();
+    const descriptor = {
+        version: 1,
+        identity,
+        schemaVersion: 1,
+        label: 'Assets',
+        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 },
+    };
+    registry.register({
+        descriptor,
+        getSnapshot: () => ({ revision: 1, state: {} }),
+    });
+    return registry;
+}
+function proposal(requestId = 'req-approve') {
+    return {
+        version: 1,
+        requestId,
+        identity,
+        actionId: 'approve',
+        phase: 'preview',
+        selection: { scope: 'explicit-ids', rowIds: ['row-sent'] },
+    };
+}
+function result(request, phase, ok, extra = {}) {
+    return {
+        version: 1,
+        requestId: request.requestId,
+        identity: request.identity,
+        actionId: request.actionId,
+        phase,
+        ok,
+        ...extra,
+    };
+}
+function client(apply) {
+    return {
+        preview: async (request) => result(request, 'preview', true, { confirmationToken: 'tok' }),
+        apply,
+    };
+}
+describe('controller onActionApplied (#2989)', () => {
+    it('fires once with the server result for an accepted apply', async () => {
+        const onActionApplied = vi.fn();
+        const controller = createAssistantDockController({
+            transport: createInMemoryAssistantTransport(),
+            registry: registryWithSurface(),
+            actionClient: client(async (request) => result(request, 'apply', true, {
+                details: { approvedAssetId: 'asset-from-server' },
+            })),
+            onActionApplied,
+        });
+        await controller.previewAction(proposal());
+        await controller.applyAction('req-approve');
+        expect(controller.actions.get('req-approve')?.status).toBe('applied');
+        expect(onActionApplied).toHaveBeenCalledTimes(1);
+        const [request, applied] = onActionApplied.mock.calls[0];
+        expect(request.phase).toBe('apply');
+        expect(request.requestId).toBe('req-approve');
+        expect(applied.details).toEqual({ approvedAssetId: 'asset-from-server' });
+        controller.dispose();
+    });
+    it('does not fire for a refusal or a thrown apply', async () => {
+        const onActionApplied = vi.fn();
+        let mode = 'refuse';
+        const controller = createAssistantDockController({
+            transport: createInMemoryAssistantTransport(),
+            registry: registryWithSurface(),
+            actionClient: client(async (request) => {
+                if (mode === 'throw')
+                    throw new Error('network down');
+                return result(request, 'apply', false, { reason: 'denied' });
+            }),
+            onActionApplied,
+        });
+        await controller.previewAction(proposal('req-a'));
+        await controller.applyAction('req-a');
+        mode = 'throw';
+        await controller.previewAction(proposal('req-b'));
+        await controller.applyAction('req-b');
+        expect(onActionApplied).not.toHaveBeenCalled();
+        controller.dispose();
+    });
+    it('keeps the applied state when the host callback throws', async () => {
+        const onActionApplied = vi.fn(() => {
+            throw new Error('host bug');
+        });
+        const controller = createAssistantDockController({
+            transport: createInMemoryAssistantTransport(),
+            registry: registryWithSurface(),
+            actionClient: client(async (request) => result(request, 'apply', true)),
+            onActionApplied,
+        });
+        await controller.previewAction(proposal());
+        await expect(controller.applyAction('req-approve')).resolves.toBeUndefined();
+        expect(onActionApplied).toHaveBeenCalledTimes(1);
+        expect(controller.actions.get('req-approve')?.status).toBe('applied');
+        controller.dispose();
+    });
+    it('does not fire for an apply that lands after a context swap', async () => {
+        const onActionApplied = vi.fn();
+        let release;
+        let registry = registryWithSurface();
+        const controller = createAssistantDockController({
+            transport: createInMemoryAssistantTransport(),
+            get registry() {
+                return registry;
+            },
+            actionClient: client(async (request) => {
+                await new Promise((resolve) => {
+                    release = resolve;
+                });
+                return result(request, 'apply', true);
+            }),
+            onActionApplied,
+        });
+        await controller.previewAction(proposal());
+        const applying = controller.applyAction('req-approve');
+        registry = registryWithSurface();
+        controller.syncRegistry();
+        release();
+        await applying;
+        expect(onActionApplied).not.toHaveBeenCalled();
+        controller.dispose();
+    });
+});
+describe('AssistantDock oncontroller / onactionapplied (#2989)', () => {
+    it('lets a host propose an action and observe the applied outcome', async () => {
+        let hostController;
+        const onactionapplied = vi.fn();
+        const oncontroller = vi.fn((c) => {
+            hostController = c;
+        });
+        render(AssistantDock, {
+            props: {
+                transport: createInMemoryAssistantTransport(),
+                registry: registryWithSurface(),
+                actionClient: client(async (request) => result(request, 'apply', true, {
+                    details: { approvedAssetId: 'asset-from-server' },
+                })),
+                oncontroller,
+                onactionapplied,
+            },
+        });
+        expect(oncontroller).toHaveBeenCalledTimes(1);
+        expect(hostController).toBeDefined();
+        await hostController?.previewAction(proposal());
+        await userEvent.click(await screen.findByRole('button', { name: 'Confirm' }));
+        await vi.waitFor(() => expect(onactionapplied).toHaveBeenCalledTimes(1));
+        expect(onactionapplied.mock.calls[0][1].details).toEqual({
+            approvedAssetId: 'asset-from-server',
+        });
+    });
+});

package/dist/svelte/components/assistant/__tests__/create-assistant-dock-controller.test.js

@@ -1870,9 +1870,11 @@ describe('createAssistantDockController', () => {
         expect(state?.error).toBe('server 500');
         controller.dispose();
     });
-    // Finding 3 (#2904 review, fresh cycle): a Reject during an in-flight
-    // apply must not be silently overridden by that apply landing afterward.
-    it('a slow apply does not resurrect a rejected action as applied', async () => {
+    // Finding 3 (#2904 review, fresh cycle) and #2990: a Reject during an
+    // in-flight apply is refused — the entry holds the only idempotency key
+    // that keeps a retry from applying twice — and the apply that lands
+    // afterward is recorded as applied, not dropped.
+    it('refuses a reject while an apply is in flight and records the landed apply', async () => {
         const { registry, identity } = realRegistryWithSurface('orders');
         let resolveApply;
         const applyGate = new Promise((resolve) => {
@@ -1920,17 +1922,14 @@ describe('createAssistantDockController', () => {
         // the first one's in-flight apply.
         await controller.applyAction(requestId);
         expect(controller.actions.get(requestId)?.status).toBe('applying');
-        // The user rejects WHILE the apply above is still in flight.
+        // The user rejects WHILE the apply above is still in flight: refused.
         controller.rejectAction(requestId);
-        expect(controller.actions.has(requestId)).toBe(false);
-        // The server mutation "lands" (resolves ok:true) after the rejection.
+        expect(controller.actions.get(requestId)?.status).toBe('applying');
+        expect(controller.error).toMatch(/rejectAction refused/);
+        // The server mutation lands; the entry records it.
         resolveApply?.(true);
         await applyPromise;
-        // The entry must NOT be resurrected as 'applied' — it stays gone.
-        expect(controller.actions.has(requestId)).toBe(false);
-        // The server mutation genuinely happened despite the rejection — the
-        // controller surfaces that as a message rather than hiding it.
-        expect(controller.messages.some((m) => m.content.includes('already applied by the server'))).toBe(true);
+        expect(controller.actions.get(requestId)?.status).toBe('applied');
         controller.dispose();
     });
     // Cycle-4 second final finding 2: the `else if (!current && result.ok)`