@taskforcehq/taskforce 0.3.305 → 0.3.307

package/dist/components/features/AgentsModule.test.js

@@ -5,11 +5,18 @@ import { AgentsModule } from './AgentsModule';
 describe('AgentsModule', () => {
     afterEach(() => {
         vi.restoreAllMocks();
+        vi.unstubAllGlobals();
     });
     it('groups registered AI profiles by surface type in a stable section order', async () => {
-        const fetchMock = vi.fn().mockResolvedValue({
+        const fetchMock = vi.fn()
+            .mockResolvedValueOnce({
             ok: true,
             json: async () => ({
+                aiProfileSeatUsage: {
+                    used: 2,
+                    limit: null,
+                    remaining: null
+                },
                 assignees: [
                     { value: 'member-1', label: 'Member One', kind: 'member' },
                     {
@@ -20,6 +27,7 @@ describe('AgentsModule', () => {
                         color: '#10a37f',
                         kind: 'agent',
                         surfaceType: 'chat_app',
+                        seatScope: 'cloud_metered',
                         description: 'General-purpose chat surface for planning and writing.',
                         role: 'Product copilot',
                         provider: 'OpenAI',
@@ -36,6 +44,7 @@ describe('AgentsModule', () => {
                         color: '#0ea5e9',
                         kind: 'agent',
                         surfaceType: 'coding_tool',
+                        seatScope: 'local_unmetered',
                         description: 'Terminal-first coding agent.',
                         role: 'Implementation partner',
                         provider: 'OpenAI',
@@ -52,6 +61,7 @@ describe('AgentsModule', () => {
                         color: '#0ea5e9',
                         kind: 'agent',
                         surfaceType: 'coding_tool',
+                        seatScope: 'local_unmetered',
                         description: 'Duplicate Codex profile.',
                         role: 'Implementation partner',
                         provider: 'OpenAI',
@@ -68,6 +78,7 @@ describe('AgentsModule', () => {
                         color: '#64748b',
                         kind: 'agent',
                         surfaceType: null,
+                        seatScope: 'cloud_metered',
                         createdAt: '2026-03-28T08:00:00.000Z',
                         updatedAt: '2026-04-01T08:00:00.000Z',
                         lastActiveAt: null
@@ -76,27 +87,515 @@ describe('AgentsModule', () => {
             })
         });
         vi.stubGlobal('fetch', fetchMock);
-        const { container } = render(_jsx(AgentsModule, { workspaceId: "workspace-1" }));
+        const { container } = render(_jsx(AgentsModule, { workspaceId: "workspace-1", cloudAuthConfigured: true, authSessionResolved: true, isAuthenticated: true, cloudAiProfileSeatUsage: { used: 2, limit: 5, remaining: 3 } }));
         await waitFor(() => expect(fetchMock).toHaveBeenCalledTimes(1));
         expect((await screen.findAllByText('Chat Apps')).length).toBeGreaterThan(0);
         expect(screen.getAllByText('Coding Tools').length).toBeGreaterThan(0);
-        expect(screen.getByText('Unclassified')).toBeInTheDocument();
+        expect(screen.getAllByText('Unclassified').length).toBeGreaterThan(0);
         expect(screen.getAllByText('Codex')).toHaveLength(1);
-        expect(screen.getByText(/2 duplicates/i)).toBeInTheDocument();
-        expect(screen.getByText('Coding tool')).toBeInTheDocument();
+        expect(screen.getByText(/1 duplicate/i)).toBeInTheDocument();
+        expect(screen.getAllByTitle('Cloud MCP').length).toBeGreaterThan(0);
+        expect(screen.getAllByTitle('Local MCP').length).toBeGreaterThan(0);
+        expect(screen.getByText('Registered Cloud Agents: 2/5')).toBeInTheDocument();
         expect(screen.getAllByText('General-purpose chat surface for planning and writing.').length).toBeGreaterThan(0);
         expect(screen.getAllByText('Product copilot').length).toBeGreaterThan(0);
-        expect(screen.getByText('OpenAI · gpt-5.4')).toBeInTheDocument();
-        expect(screen.getByText(/Profile instances/i)).toBeInTheDocument();
+        expect(screen.getAllByText('OpenAI').length).toBeGreaterThan(0);
+        expect(screen.getAllByText('gpt-5.4').length).toBeGreaterThan(0);
+        expect(screen.queryByText(/Profile instances/i)).not.toBeInTheDocument();
+        expect(screen.queryByText(/Choose a keeper here if duplicates need to be merged/i)).not.toBeInTheDocument();
         const text = container.textContent || '';
         expect(text.indexOf('Chat Apps')).toBeLessThan(text.indexOf('Coding Tools'));
         expect(text.indexOf('Coding Tools')).toBeLessThan(text.indexOf('Unclassified'));
         fireEvent.click(screen.getByRole('button', { name: /codex/i }));
+        expect(screen.getByText('Coding Tool')).toBeInTheDocument();
         expect(screen.getAllByText('Terminal-first coding agent.').length).toBeGreaterThan(0);
         expect(screen.getAllByText('Implementation partner')[0]).toBeInTheDocument();
-        expect(screen.getByText('OpenAI · gpt-5-codex')).toBeInTheDocument();
+        expect(screen.getAllByText('OpenAI').length).toBeGreaterThan(0);
+        expect(screen.getAllByText('gpt-5-codex').length).toBeGreaterThan(0);
         expect(screen.getByText(/2 linked/i)).toBeInTheDocument();
+        expect(screen.getByText(/Profile instances/i)).toBeInTheDocument();
+        expect(screen.getByText(/Choose a keeper here if duplicates need to be merged/i)).toBeInTheDocument();
         expect(screen.getAllByTitle('Keep this profile, merge others into it')).toHaveLength(2);
         expect(screen.getByText('@codex-duplicate')).toBeInTheDocument();
+        expect(screen.getAllByTitle('Cloud MCP').length).toBeGreaterThan(0);
+        expect(screen.getAllByTitle('Local MCP').length).toBeGreaterThan(0);
+    });
+    it('does not mark local and cloud profiles with the same name as duplicates', async () => {
+        const fetchMock = vi.fn()
+            .mockResolvedValueOnce({
+            ok: true,
+            json: async () => ({
+                aiProfileSeatUsage: {
+                    used: 1,
+                    limit: null,
+                    remaining: null
+                },
+                assignees: [
+                    {
+                        value: 'ai-codex-local',
+                        label: 'Codex',
+                        username: 'codex',
+                        icon: 'Bot',
+                        color: '#0ea5e9',
+                        kind: 'agent',
+                        surfaceType: 'cli',
+                        seatScope: 'local_unmetered',
+                        description: 'Terminal-first coding agent.',
+                        role: 'Coding Agent',
+                        provider: 'OpenAI',
+                        model: 'Codex',
+                        createdAt: '2026-04-02T09:00:00.000Z',
+                        updatedAt: '2026-04-04T13:15:00.000Z',
+                        lastActiveAt: '2026-04-04T13:45:00.000Z'
+                    },
+                    {
+                        value: 'ai-codex-cloud',
+                        label: 'Codex',
+                        username: 'codex',
+                        icon: 'Bot',
+                        color: '#0ea5e9',
+                        kind: 'agent',
+                        surfaceType: 'cli',
+                        seatScope: 'cloud_metered',
+                        description: 'Cloud MCP coding profile.',
+                        role: 'Coding Agent',
+                        provider: 'OpenAI',
+                        model: 'Codex',
+                        createdAt: '2026-04-02T10:00:00.000Z',
+                        updatedAt: '2026-04-04T13:16:00.000Z',
+                        lastActiveAt: '2026-04-04T13:46:00.000Z'
+                    }
+                ]
+            })
+        });
+        vi.stubGlobal('fetch', fetchMock);
+        render(_jsx(AgentsModule, { workspaceId: "workspace-1", cloudAuthConfigured: true, authSessionResolved: true, isAuthenticated: true, cloudAiProfileSeatUsage: { used: 1, limit: 5, remaining: 4 } }));
+        await waitFor(() => expect(fetchMock).toHaveBeenCalledTimes(1));
+        expect(screen.getAllByRole('button', { name: /codex/i })).toHaveLength(2);
+        expect(screen.queryByText(/\d+ duplicate/i)).not.toBeInTheDocument();
+        expect(screen.queryByText(/Profile instances/i)).not.toBeInTheDocument();
+        expect(screen.getAllByTitle('Cloud MCP').length).toBeGreaterThan(0);
+        expect(screen.getAllByTitle('Local MCP').length).toBeGreaterThan(0);
+    });
+    it('keeps a duplicate group avatar visible when the newest duplicate has no photo', async () => {
+        const avatarUrl = '/api/taskforce/context/workspaces%2Fworkspace-1%2Fassets%2Fimages%2Fai-profiles%2Fai-codex-old%2Favatar%2Fcropped.webp';
+        const fetchMock = vi.fn()
+            .mockResolvedValueOnce({
+            ok: true,
+            json: async () => ({
+                aiProfileSeatUsage: {
+                    used: 2,
+                    limit: null,
+                    remaining: null
+                },
+                assignees: [
+                    {
+                        value: 'ai-codex-new',
+                        label: 'Codex',
+                        username: 'codex-new',
+                        icon: 'Bot',
+                        color: '#0ea5e9',
+                        kind: 'agent',
+                        surfaceType: 'coding_tool',
+                        seatScope: 'local_unmetered',
+                        createdAt: '2026-04-02T10:00:00.000Z',
+                        updatedAt: '2026-04-04T16:00:00.000Z',
+                        lastActiveAt: '2026-04-04T16:30:00.000Z',
+                        avatarUrl: null,
+                        avatarSourceUrl: null
+                    },
+                    {
+                        value: 'ai-codex-old',
+                        label: 'Codex',
+                        username: 'codex-old',
+                        icon: 'Bot',
+                        color: '#0ea5e9',
+                        kind: 'agent',
+                        surfaceType: 'coding_tool',
+                        seatScope: 'local_unmetered',
+                        createdAt: '2026-04-02T09:00:00.000Z',
+                        updatedAt: '2026-04-04T13:15:00.000Z',
+                        lastActiveAt: '2026-04-04T13:45:00.000Z',
+                        avatarUrl,
+                        avatarSourceUrl: avatarUrl
+                    }
+                ]
+            })
+        });
+        vi.stubGlobal('fetch', fetchMock);
+        render(_jsx(AgentsModule, { workspaceId: "workspace-1", cloudAuthConfigured: true, authSessionResolved: true, isAuthenticated: true, cloudAiProfileSeatUsage: { used: 2, limit: 5, remaining: 3 } }));
+        const codexButton = await screen.findByRole('button', { name: /codex/i });
+        expect(codexButton.querySelector('img')).toHaveAttribute('src', avatarUrl);
+        expect(screen.getByLabelText('Edit AI profile photo').querySelector('img')).toHaveAttribute('src', avatarUrl);
+    });
+    it('uploads AI profile avatars through the stable avatar endpoint', async () => {
+        const avatarUrl = '/api/taskforce/context/workspaces%2Fworkspace-1%2Fassets%2Fimages%2Fai-profiles%2Fai-codex%2Favatar%2Fdisplay.gif';
+        const fetchMock = vi.fn(async (input, init) => {
+            const url = String(input);
+            if (url.startsWith('/api/taskforce/workspace/assignee-options')) {
+                return {
+                    ok: true,
+                    json: async () => ({
+                        aiProfileSeatUsage: {
+                            used: 1,
+                            limit: null,
+                            remaining: null
+                        },
+                        assignees: [
+                            {
+                                value: 'ai-codex',
+                                label: 'Codex',
+                                username: 'codex',
+                                icon: 'Bot',
+                                color: '#0ea5e9',
+                                kind: 'agent',
+                                surfaceType: 'coding_tool',
+                                seatScope: 'cloud_metered',
+                                createdAt: '2026-04-02T09:00:00.000Z',
+                                updatedAt: '2026-04-04T13:15:00.000Z',
+                                lastActiveAt: '2026-04-04T13:45:00.000Z',
+                                avatarUrl: null,
+                                avatarSourceUrl: null
+                            }
+                        ]
+                    })
+                };
+            }
+            if (url === '/api/taskforce/workspace/ai-profiles/avatar/upload') {
+                return {
+                    ok: true,
+                    json: async () => ({
+                        profile: {
+                            id: 'ai-codex',
+                            avatarUrl,
+                            avatarSourceUrl: '/api/taskforce/context/workspaces%2Fworkspace-1%2Fassets%2Fimages%2Fai-profiles%2Fai-codex%2Favatar%2Fsource.gif',
+                            avatarRevision: 1,
+                            avatarUpdatedAt: '2026-04-28T00:00:00.000Z'
+                        }
+                    })
+                };
+            }
+            throw new Error(`Unexpected fetch ${url}: ${String(init?.body || '')}`);
+        });
+        vi.stubGlobal('fetch', fetchMock);
+        vi.stubGlobal('URL', {
+            ...URL,
+            createObjectURL: vi.fn(() => 'blob:avatar-preview'),
+            revokeObjectURL: vi.fn()
+        });
+        render(_jsx(AgentsModule, { workspaceId: "workspace-1", cloudAuthConfigured: true, authSessionResolved: true, isAuthenticated: true, cloudAiProfileSeatUsage: { used: 1, limit: 5, remaining: 4 } }));
+        fireEvent.click(await screen.findByLabelText('Edit AI profile photo'));
+        const input = await screen.findByLabelText('Choose profile photo');
+        const file = new File(['avatar'], 'avatar.gif', { type: 'image/gif' });
+        fireEvent.change(input, { target: { files: [file] } });
+        fireEvent.click(screen.getByRole('button', { name: 'Apply Photo' }));
+        await waitFor(() => {
+            expect(fetchMock).toHaveBeenCalledWith('/api/taskforce/workspace/ai-profiles/avatar/upload', expect.objectContaining({ method: 'POST' }));
+        });
+        const uploadBody = JSON.parse(String(fetchMock.mock.calls.find((call) => call[0] === '/api/taskforce/workspace/ai-profiles/avatar/upload')?.[1]?.body || '{}'));
+        expect(uploadBody).toEqual(expect.objectContaining({
+            profileId: 'ai-codex',
+            displayImage: expect.objectContaining({
+                mimeType: 'image/gif',
+                originalName: 'avatar.gif'
+            })
+        }));
+        expect(String(uploadBody.displayImage.dataUrl)).toMatch(new RegExp('^data:image/gif;base64,'));
+        expect(fetchMock.mock.calls.some((call) => call[0] === '/api/taskforce/context-upload/init')).toBe(false);
+        expect(fetchMock.mock.calls.some((call) => call[0] === '/api/taskforce/context-upload/finalize')).toBe(false);
+        expect(fetchMock.mock.calls.some((call) => call[0] === '/api/taskforce/context-upload' && String(call[1]?.method || '').toUpperCase() === 'POST')).toBe(false);
+    });
+    it('removes a profile from the active roster and reloads the list', async () => {
+        const confirmMock = vi.fn().mockReturnValue(true);
+        const fetchMock = vi.fn()
+            .mockResolvedValueOnce({
+            ok: true,
+            json: async () => ({
+                aiProfileSeatUsage: {
+                    used: 1,
+                    limit: null,
+                    remaining: null
+                },
+                assignees: [
+                    {
+                        value: 'ai-codex',
+                        label: 'Codex',
+                        username: 'codex',
+                        icon: 'Bot',
+                        color: '#0ea5e9',
+                        kind: 'agent',
+                        surfaceType: 'coding_tool',
+                        description: 'Terminal-first coding agent.',
+                        role: 'Implementation partner',
+                        provider: 'OpenAI',
+                        model: 'gpt-5-codex',
+                        createdAt: '2026-04-02T09:00:00.000Z',
+                        updatedAt: '2026-04-04T13:15:00.000Z',
+                        lastActiveAt: '2026-04-04T13:45:00.000Z'
+                    }
+                ]
+            })
+        })
+            .mockResolvedValueOnce({
+            ok: true,
+            json: async () => ({
+                profile: {
+                    id: 'ai-codex',
+                    archivedReason: 'manual_archive'
+                }
+            })
+        })
+            .mockResolvedValueOnce({
+            ok: true,
+            json: async () => ({
+                aiProfileSeatUsage: {
+                    used: 0,
+                    limit: null,
+                    remaining: null
+                },
+                assignees: []
+            })
+        });
+        vi.stubGlobal('fetch', fetchMock);
+        vi.stubGlobal('confirm', confirmMock);
+        render(_jsx(AgentsModule, { workspaceId: "workspace-1", cloudAuthConfigured: true, authSessionResolved: true, isAuthenticated: true, cloudAiProfileSeatUsage: { used: 1, limit: 3, remaining: 2 } }));
+        expect(await screen.findByRole('button', { name: /codex/i })).toBeInTheDocument();
+        fireEvent.change(screen.getByLabelText('Agent roster status'), { target: { value: 'retire' } });
+        await waitFor(() => expect(confirmMock).toHaveBeenCalledTimes(1));
+        expect(fetchMock).toHaveBeenNthCalledWith(2, '/api/taskforce/workspace/ai-profiles/archive', expect.objectContaining({
+            method: 'POST',
+            credentials: 'include'
+        }));
+        expect(fetchMock).toHaveBeenNthCalledWith(3, '/api/taskforce/workspace/assignee-options?workspaceId=workspace-1&kind=agent', expect.objectContaining({
+            credentials: 'include'
+        }));
+        expect(await screen.findByText('AI profile removed from active roster.')).toBeInTheDocument();
+        expect(await screen.findByText('No AI profiles registered yet.')).toBeInTheDocument();
+    });
+    it('updates an AI profile category from the detail dropdown', async () => {
+        const fetchMock = vi.fn(async (input, init) => {
+            const url = String(input);
+            if (url.startsWith('/api/taskforce/workspace/assignee-options')) {
+                return {
+                    ok: true,
+                    json: async () => ({
+                        aiProfileSeatUsage: {
+                            used: 1,
+                            limit: null,
+                            remaining: null
+                        },
+                        assignees: [
+                            {
+                                value: 'ai-chatgpt',
+                                label: 'ChatGPT',
+                                username: 'chatgpt',
+                                icon: 'Bot',
+                                color: '#10a37f',
+                                kind: 'agent',
+                                surfaceType: 'chat_app',
+                                seatScope: 'cloud_metered',
+                                provider: 'OpenAI',
+                                model: 'GPT-5',
+                                createdAt: '2026-04-02T09:00:00.000Z',
+                                updatedAt: '2026-04-04T13:15:00.000Z',
+                                lastActiveAt: '2026-04-04T13:45:00.000Z'
+                            }
+                        ]
+                    })
+                };
+            }
+            if (url === '/api/taskforce/workspace/ai-profiles/surface-type') {
+                return {
+                    ok: true,
+                    json: async () => ({
+                        profile: {
+                            id: 'ai-chatgpt',
+                            surfaceType: 'cli',
+                            updatedAt: '2026-04-28T00:00:00.000Z'
+                        }
+                    })
+                };
+            }
+            throw new Error(`Unexpected fetch ${url}: ${String(init?.body || '')}`);
+        });
+        vi.stubGlobal('fetch', fetchMock);
+        render(_jsx(AgentsModule, { workspaceId: "workspace-1", cloudAuthConfigured: true, authSessionResolved: true, isAuthenticated: true, cloudAiProfileSeatUsage: { used: 1, limit: 3, remaining: 2 } }));
+        const categorySelect = await screen.findByLabelText('Agent category');
+        fireEvent.change(categorySelect, { target: { value: 'cli' } });
+        await waitFor(() => {
+            expect(fetchMock).toHaveBeenCalledWith('/api/taskforce/workspace/ai-profiles/surface-type', expect.objectContaining({
+                method: 'POST',
+                credentials: 'include',
+                body: JSON.stringify({
+                    profileId: 'ai-chatgpt',
+                    surfaceType: 'cli'
+                })
+            }));
+        });
+        expect(await screen.findByText('AI profile category updated.')).toBeInTheDocument();
+        expect(screen.getByLabelText('Agent category').value).toBe('cli');
+        expect(screen.getAllByText('CLI').length).toBeGreaterThan(0);
+    });
+    it('shows archive permission errors inline near the roster status control', async () => {
+        const confirmMock = vi.fn().mockReturnValue(true);
+        const fetchMock = vi.fn()
+            .mockResolvedValueOnce({
+            ok: true,
+            json: async () => ({
+                aiProfileSeatUsage: {
+                    used: 1,
+                    limit: null,
+                    remaining: null
+                },
+                assignees: [
+                    {
+                        value: 'ai-codex',
+                        label: 'Codex',
+                        username: 'codex',
+                        icon: 'Bot',
+                        color: '#0ea5e9',
+                        kind: 'agent',
+                        surfaceType: 'coding_tool',
+                        description: 'Terminal-first coding agent.',
+                        role: 'Implementation partner',
+                        provider: 'OpenAI',
+                        model: 'gpt-5-codex',
+                        createdAt: '2026-04-02T09:00:00.000Z',
+                        updatedAt: '2026-04-04T13:15:00.000Z',
+                        lastActiveAt: '2026-04-04T13:45:00.000Z'
+                    }
+                ]
+            })
+        })
+            .mockResolvedValueOnce({
+            ok: false,
+            json: async () => ({
+                error: 'Forbidden: owner or admin role required.'
+            })
+        });
+        vi.stubGlobal('fetch', fetchMock);
+        vi.stubGlobal('confirm', confirmMock);
+        render(_jsx(AgentsModule, { workspaceId: "workspace-1", cloudAuthConfigured: true, authSessionResolved: true, isAuthenticated: true, cloudAiProfileSeatUsage: { used: 1, limit: 3, remaining: 2 } }));
+        expect(await screen.findByRole('button', { name: /codex/i })).toBeInTheDocument();
+        fireEvent.change(screen.getByLabelText('Agent roster status'), { target: { value: 'retire' } });
+        const inlineError = await screen.findByRole('alert');
+        expect(inlineError).toHaveTextContent('Forbidden: owner or admin role required.');
+        expect(screen.getByLabelText('Agent roster status')).toBeInTheDocument();
+    });
+    it('falls back to local seat usage only when cloud auth is not configured', async () => {
+        const fetchMock = vi.fn()
+            .mockResolvedValueOnce({
+            ok: true,
+            json: async () => ({
+                aiProfileSeatUsage: {
+                    used: 1,
+                    limit: 3,
+                    remaining: 2
+                },
+                assignees: [
+                    {
+                        value: 'ai-codex',
+                        label: 'Codex',
+                        username: 'codex',
+                        icon: 'Bot',
+                        color: '#0ea5e9',
+                        kind: 'agent',
+                        surfaceType: 'coding_tool',
+                        seatScope: 'local_unmetered',
+                        createdAt: '2026-04-02T09:00:00.000Z',
+                        updatedAt: '2026-04-04T13:15:00.000Z',
+                        lastActiveAt: '2026-04-04T13:45:00.000Z'
+                    }
+                ]
+            })
+        });
+        vi.stubGlobal('fetch', fetchMock);
+        render(_jsx(AgentsModule, { workspaceId: "workspace-1" }));
+        expect(await screen.findByText('Registered Cloud Agents: 1/3')).toBeInTheDocument();
+    });
+    it('shows no cloud seat label when cloud auth is configured but cloud seat usage is unavailable', async () => {
+        const fetchMock = vi.fn()
+            .mockResolvedValueOnce({
+            ok: true,
+            json: async () => ({
+                aiProfileSeatUsage: {
+                    used: 0,
+                    limit: null,
+                    remaining: null
+                },
+                assignees: [
+                    {
+                        value: 'ai-codex',
+                        label: 'Codex',
+                        username: 'codex',
+                        icon: 'Bot',
+                        color: '#0ea5e9',
+                        kind: 'agent',
+                        surfaceType: 'coding_tool',
+                        seatScope: 'cloud_metered',
+                        createdAt: '2026-04-02T09:00:00.000Z',
+                        updatedAt: '2026-04-04T13:15:00.000Z',
+                        lastActiveAt: '2026-04-04T13:45:00.000Z'
+                    }
+                ]
+            })
+        });
+        vi.stubGlobal('fetch', fetchMock);
+        render(_jsx(AgentsModule, { workspaceId: "workspace-1", cloudAuthConfigured: true, authSessionResolved: true, isAuthenticated: true }));
+        await screen.findByRole('button', { name: /codex/i });
+        expect(screen.queryByText(/Registered Cloud Agents:/i)).not.toBeInTheDocument();
+        expect(screen.queryByText('Registered Cloud Agents: 0/Unlimited')).not.toBeInTheDocument();
+    });
+    it('shows resolved cloud seat usage when the account summary updates after mount', async () => {
+        const fetchMock = vi.fn()
+            .mockResolvedValueOnce({
+            ok: true,
+            json: async () => ({
+                aiProfileSeatUsage: {
+                    used: 0,
+                    limit: null,
+                    remaining: null
+                },
+                assignees: [
+                    {
+                        value: 'ai-codex',
+                        label: 'Codex',
+                        username: 'codex',
+                        icon: 'Bot',
+                        color: '#0ea5e9',
+                        kind: 'agent',
+                        surfaceType: 'coding_tool',
+                        seatScope: 'cloud_metered',
+                        createdAt: '2026-04-02T09:00:00.000Z',
+                        updatedAt: '2026-04-04T13:15:00.000Z',
+                        lastActiveAt: '2026-04-04T13:45:00.000Z'
+                    }
+                ]
+            })
+        });
+        vi.stubGlobal('fetch', fetchMock);
+        const { rerender } = render(_jsx(AgentsModule, { workspaceId: "workspace-1", cloudAuthConfigured: true, authSessionResolved: true, isAuthenticated: true, cloudAiProfileSeatUsage: null }));
+        await screen.findByRole('button', { name: /codex/i });
+        expect(screen.queryByText(/Registered Cloud Agents:/i)).not.toBeInTheDocument();
+        rerender(_jsx(AgentsModule, { workspaceId: "workspace-1", cloudAuthConfigured: true, authSessionResolved: true, isAuthenticated: true, cloudAiProfileSeatUsage: { used: 0, limit: 20, remaining: 20 } }));
+        expect(await screen.findByText('Registered Cloud Agents: 0/20')).toBeInTheDocument();
+    });
+    it('shows a cloud login prompt instead of unlimited when cloud auth is configured but the user is signed out', async () => {
+        const fetchMock = vi.fn()
+            .mockResolvedValueOnce({
+            ok: true,
+            json: async () => ({
+                aiProfileSeatUsage: {
+                    used: 0,
+                    limit: null,
+                    remaining: null
+                },
+                assignees: []
+            })
+        });
+        vi.stubGlobal('fetch', fetchMock);
+        render(_jsx(AgentsModule, { workspaceId: "workspace-1", cloudAuthConfigured: true, authSessionResolved: true, isAuthenticated: false }));
+        expect(await screen.findByText('Log into account for Cloud agents')).toBeInTheDocument();
+        expect(screen.queryByText('Registered Cloud Agents: 0/Unlimited')).not.toBeInTheDocument();
     });
 });

package/dist/components/features/AnnotatedAttachmentWorkspace.d.ts

@@ -8,6 +8,8 @@ type ShellProps = {
     requestedTarget?: OpenAnnotatedAttachmentDetail | null;
     requestedSessionId?: string | null;
     requestedOpenVersion?: number;
+    imageTrayOpen?: boolean;
+    onCloseImageTray?: () => void;
     resolveTaskReferenceLabel?: (taskId: string) => string;
     resolveImageReferenceLabel?: (assetId: string) => string;
     onRequestedTargetHandled?: () => void;
@@ -20,5 +22,5 @@ type ShellProps = {
     }) => void;
     onBackToTask?: (taskId: string) => void;
 };
-export declare function AnnotatedAttachmentWorkspaceShell({ runtimeMode, apiBaseUrl, cloudAuthBaseUrl, workspaceId, sessionLoadReady, requestedTarget, requestedSessionId, requestedOpenVersion, resolveTaskReferenceLabel, resolveImageReferenceLabel, onRequestedTargetHandled, onOpenTarget, onContextChange, onBackToTask, }: ShellProps): import("react/jsx-runtime").JSX.Element;
+export declare function AnnotatedAttachmentWorkspaceShell({ runtimeMode, apiBaseUrl, cloudAuthBaseUrl, workspaceId, sessionLoadReady, requestedTarget, requestedSessionId, requestedOpenVersion, imageTrayOpen, onCloseImageTray, resolveTaskReferenceLabel, resolveImageReferenceLabel, onRequestedTargetHandled, onOpenTarget, onContextChange, onBackToTask, }: ShellProps): import("react/jsx-runtime").JSX.Element;
 export {};