@taskforcehq/taskforce 0.3.169 → 0.3.300

package/dist/components/task/TaskCard.test.js

@@ -1,7 +1,7 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { render, screen } from '@testing-library/react';
 import userEvent from '@testing-library/user-event';
-import { describe, it, expect } from 'vitest';
+import { describe, it, expect, vi } from 'vitest';
 import { TaskCard } from './TaskCard';
 const baseTask = (overrides) => ({
     id: 'task-default',
@@ -14,62 +14,130 @@ const baseTask = (overrides) => ({
     createdAt: '2026-02-13T00:00:00.000Z',
     ...overrides
 });
+const baseWorkstream = (overrides = {}) => ({
+    id: 'workstream-1',
+    referenceNumber: 12,
+    title: 'Platform polish',
+    description: '',
+    createdAt: '2026-02-13T00:00:00.000Z',
+    ...overrides,
+});
+const baseInitiative = (overrides = {}) => ({
+    id: 'initiative-1',
+    referenceNumber: 3,
+    title: 'Execution model',
+    description: '',
+    createdAt: '2026-02-13T00:00:00.000Z',
+    ...overrides,
+});
 describe('TaskCard parent/child progress', () => {
-    it('counts archived children as completed in progress percent', () => {
-        const parent = baseTask({ id: 'task-parent', title: 'Parent Task' });
-        const childDone = baseTask({
-            id: 'task-child-done',
-            title: 'Done Child',
-            parentTaskId: parent.id,
-            status: 'done'
-        });
-        const childArchived = baseTask({
-            id: 'task-child-archived',
-            title: 'Archived Child',
-            parentTaskId: parent.id,
-            status: 'task',
-            isArchived: true
-        });
-        render(_jsx(TaskCard, { task: parent, allTasks: [parent, childDone, childArchived], onClick: () => { }, onCopyId: () => { } }));
-        const progressBar = screen.getByTitle('2 of 2 child tasks are done/cancelled (100%)');
-        expect(progressBar).toBeInTheDocument();
-        const fill = progressBar.firstElementChild;
-        expect(fill).toBeTruthy();
-        expect(fill?.style.width).toBe('100%');
-    });
-    it('renders archived child tasks after non-archived child tasks', async () => {
+    it('renders initiative/workstream/task hierarchy references when planning context is provided', () => {
+        const task = baseTask({
+            id: 'task-hierarchy',
+            referenceNumber: 658,
+            title: 'Task with hierarchy',
+            workstreamId: 'workstream-1',
+        });
+        render(_jsx(TaskCard, { task: task, taskWorkstream: baseWorkstream({ initiativeId: 'initiative-1', referenceNumber: 637 }), taskInitiative: baseInitiative({ referenceNumber: 3 }), onClick: () => { }, onCopyId: () => { } }));
+        expect(screen.getByText('IN-3')).toBeInTheDocument();
+        expect(screen.getByText('WS-637')).toBeInTheDocument();
+        expect(screen.getByText('T-658')).toBeInTheDocument();
+    });
+    it('copies the task badge without opening the task card when hierarchy text is shown', async () => {
         const user = userEvent.setup();
-        const parent = baseTask({ id: 'task-parent-2', title: 'Parent Task 2' });
-        const activeChild = baseTask({
-            id: 'task-child-active',
-            title: 'Active Child',
-            parentTaskId: parent.id,
-            status: 'task',
-            isArchived: false,
-            createdAt: '2026-02-13T02:00:00.000Z'
-        });
-        const archivedChild = baseTask({
-            id: 'task-child-archived-2',
-            title: 'Archived Child',
-            parentTaskId: parent.id,
-            status: 'done',
-            isArchived: true,
-            createdAt: '2026-02-13T03:00:00.000Z'
-        });
-        const { container } = render(_jsx(TaskCard, { task: parent, allTasks: [parent, archivedChild, activeChild], onClick: () => { }, onCopyId: () => { } }));
-        await user.click(screen.getByRole('button', { name: /child tasks: 2/i }));
-        const text = container.textContent || '';
-        const activeIndex = text.indexOf('Active Child');
-        const archivedIndex = text.indexOf('Archived Child');
-        expect(activeIndex).toBeGreaterThanOrEqual(0);
-        expect(archivedIndex).toBeGreaterThanOrEqual(0);
-        expect(activeIndex).toBeLessThan(archivedIndex);
-    });
-    it('renders markdown context attachments with MD type badge', () => {
+        const handleClick = vi.fn();
+        const handleCopyId = vi.fn();
+        const task = baseTask({
+            id: 'task-hierarchy-copy',
+            referenceNumber: 200,
+            title: 'Copy hierarchy',
+            workstreamId: 'workstream-2',
+        });
+        render(_jsx(TaskCard, { task: task, taskWorkstream: baseWorkstream({ id: 'workstream-2', referenceNumber: 19 }), taskInitiative: baseInitiative({ referenceNumber: 8 }), onClick: handleClick, onCopyId: handleCopyId }));
+        await user.click(screen.getByTitle('Copy task reference'));
+        expect(handleCopyId).toHaveBeenCalledWith(expect.any(Object), 'T-200');
+        expect(handleClick).not.toHaveBeenCalled();
+    });
+    it('uses the latest audit event for the latest activity summary and count badge', () => {
+        const task = baseTask({
+            id: 'task-audit-summary',
+            title: 'Audit summary task',
+            comments: [
+                {
+                    id: 'comment-1',
+                    author: 'user',
+                    text: 'Earlier discussion',
+                    timestamp: '2026-03-22T09:00:00.000Z'
+                }
+            ],
+            activity: [
+                {
+                    id: 'comment:comment-1',
+                    type: 'comment',
+                    timestamp: '2026-03-22T09:00:00.000Z',
+                    comment: {
+                        id: 'comment-1',
+                        author: 'user',
+                        text: 'Earlier discussion',
+                        timestamp: '2026-03-22T09:00:00.000Z'
+                    }
+                },
+                {
+                    id: 'event:event-1',
+                    type: 'event',
+                    timestamp: '2026-03-22T10:00:00.000Z',
+                    event: {
+                        id: 'event-1',
+                        taskId: 'task-audit-summary',
+                        workspaceId: 'default',
+                        action: 'task-status-changed',
+                        actor: 'user',
+                        actorType: 'human',
+                        createdAt: '2026-03-22T10:00:00.000Z',
+                        details: {
+                            changes: {
+                                status: { from: 'task', to: 'review' }
+                            }
+                        }
+                    }
+                }
+            ]
+        });
+        render(_jsx(TaskCard, { task: task, onClick: () => { }, onCopyId: () => { } }));
+        expect(screen.getByText(/Latest Activity:/)).toBeInTheDocument();
+        expect(screen.getByText(/Status: task -> review/)).toBeInTheDocument();
+        expect(screen.getByTitle('2 activity items')).toBeInTheDocument();
+    });
+    it('renders named AI assignee labels from assignee options', () => {
+        const task = baseTask({
+            id: 'task-ai-assignee',
+            title: 'AI-owned task',
+            assignee: 'ai-profile-123'
+        });
+        render(_jsx(TaskCard, { task: task, assigneeOptions: [
+                { value: 'unassigned', label: 'Unassigned', icon: 'HelpCircle', color: 'var(--text-secondary)', kind: 'unassigned' },
+                { value: 'ai-profile-123', label: 'Codex', icon: 'Bot', color: '#0ea5e9', kind: 'agent' }
+            ], onClick: () => { }, onCopyId: () => { } }));
+        expect(screen.getByLabelText('Assigned to Codex')).toBeInTheDocument();
+    });
+    it('prefers provided type metadata over hardcoded defaults', () => {
+        const task = baseTask({
+            id: 'task-type-metadata',
+            title: 'Typed task',
+            type: 'task'
+        });
+        render(_jsx(TaskCard, { task: task, types: [
+                { value: 'task', label: 'Task', icon: 'Star', color: '#123456' }
+            ], onClick: () => { }, onCopyId: () => { } }));
+        expect(screen.getByTitle('Task')).toHaveStyle({
+            color: 'var(--type-color, #123456)'
+        });
+    });
+    it('renders markdown context attachments as document chips with a visible name and type badge', () => {
         const task = baseTask({
             id: 'task-md-context',
             title: 'Task with markdown context',
-            screenshots: [
+            attachments: [
                 {
                     path: '/api/taskforce/context/task-data%2Ftask-md-context%2Fattachments%2Fnotes-123.bin',
                     fsPath: '.taskforce/task-data/task-md-context/attachments/notes.md',
@@ -77,19 +145,303 @@ describe('TaskCard parent/child progress', () => {
                 }
             ]
         });
-        render(_jsx(TaskCard, { task: task, allTasks: [task], onClick: () => { }, onCopyId: () => { } }));
+        render(_jsx(TaskCard, { task: task, onClick: () => { }, onCopyId: () => { } }));
+        const chipName = screen.getByText('notes.md');
+        const chipButton = chipName.closest('button');
+        expect(chipName).toBeInTheDocument();
         expect(screen.getByText('MD')).toBeInTheDocument();
+        expect(chipButton).toHaveAttribute('title', 'notes.md');
+    });
+    it('dispatches canonical document identity for cloud-backed markdown attachments', async () => {
+        const user = userEvent.setup();
+        const dispatchSpy = vi.spyOn(window, 'dispatchEvent');
+        const task = baseTask({
+            id: 'task-cloud-doc-context',
+            title: 'Task with cloud doc context',
+            attachments: [
+                {
+                    path: '/api/taskforce/documents/asset-doc-cloud-1/content',
+                    fsPath: 'workspaces/workspace-1/assets/documents/asset-doc-cloud-1-implementation-plan.md',
+                    assetId: 'asset-doc-cloud-1',
+                    originalFilename: 'implementation-plan.md',
+                    caption: 'implementation-plan.md'
+                }
+            ]
+        });
+        render(_jsx(TaskCard, { task: task, onClick: () => { }, onCopyId: () => { } }));
+        await user.click(screen.getByRole('button', { name: /implementation plan\.md md/i }));
+        expect(dispatchSpy).toHaveBeenCalledWith(expect.objectContaining({
+            type: 'taskforce:open-markdown-document',
+            detail: expect.objectContaining({
+                path: '/api/taskforce/documents/asset-doc-cloud-1/content',
+                fsPath: 'workspaces/workspace-1/assets/documents/asset-doc-cloud-1-implementation-plan.md',
+                assetId: 'asset-doc-cloud-1'
+            })
+        }));
+        dispatchSpy.mockRestore();
+    });
+    it('prefers the canonical document name over a stale caption for markdown document chips', () => {
+        const task = baseTask({
+            id: 'task-cloud-doc-stale-caption',
+            title: 'Task with stale cloud doc caption',
+            attachments: [
+                {
+                    path: '/api/taskforce/documents/asset-doc-cloud-2/content',
+                    fsPath: 'workspaces/workspace-1/assets/documents/asset-doc-cloud-2-v2.md',
+                    assetId: 'asset-doc-cloud-2',
+                    displayName: 'AI Profiles - Implementation Plan v2',
+                    originalFilename: 'v2.md',
+                    caption: 'asset-doc-cloud-2'
+                }
+            ]
+        });
+        render(_jsx(TaskCard, { task: task, onClick: () => { }, onCopyId: () => { } }));
+        const chipName = screen.getByText('AI Profiles - Implementation Plan v2.md');
+        expect(chipName).toBeInTheDocument();
+        expect(screen.queryByText('asset-doc-cloud-2')).not.toBeInTheDocument();
+    });
+    it('keeps canonical document chips filename-first without D- references', () => {
+        const task = baseTask({
+            id: 'task-cloud-doc-reference',
+            title: 'Task with document reference chip',
+            attachments: [
+                {
+                    path: '/api/taskforce/documents/asset-doc-cloud-3/content',
+                    fsPath: 'workspaces/workspace-1/assets/documents/asset-doc-cloud-3-implementation-plan.md',
+                    assetId: 'asset-doc-cloud-3',
+                    displayName: 'Implementation Plan',
+                    originalFilename: 'implementation-plan.md',
+                    referenceNumber: 12,
+                    referenceLabel: 'D-12',
+                    caption: 'Implementation Plan'
+                }
+            ]
+        });
+        render(_jsx(TaskCard, { task: task, onClick: () => { }, onCopyId: () => { } }));
+        expect(screen.queryByText('D-12')).not.toBeInTheDocument();
+        expect(screen.getByText('Implementation Plan.md')).toBeInTheDocument();
+    });
+    it('dispatches annotated attachment open events for image thumbnails with canonical metadata', async () => {
+        const dispatchSpy = vi.spyOn(window, 'dispatchEvent').mockReturnValue(false);
+        const user = userEvent.setup();
+        const task = baseTask({
+            id: 'task-image-annotate',
+            referenceNumber: 211,
+            title: 'Task with image attachment',
+            attachments: [
+                {
+                    path: '/api/taskforce/context/workspaces%2Fworkspace-1%2Fassets%2Fimages%2Fasset-image-1-ui.png',
+                    fsPath: 'workspaces/workspace-1/assets/images/asset-image-1-ui.png',
+                    assetId: 'asset-image-1',
+                    displayName: 'UI Screenshot',
+                    originalFilename: 'ui.png',
+                    caption: 'UI Screenshot',
+                }
+            ]
+        });
+        render(_jsx(TaskCard, { task: task, onClick: () => { }, onCopyId: () => { } }));
+        await user.click(screen.getByAltText('Attachment 0'));
+        expect(dispatchSpy).toHaveBeenCalledWith(expect.objectContaining({
+            type: 'taskforce:open-annotated-attachment',
+            detail: expect.objectContaining({
+                taskId: 'task-image-annotate',
+                taskReferenceLabel: 'T-211',
+                assetId: 'asset-image-1',
+                path: '/api/taskforce/context/workspaces%2Fworkspace-1%2Fassets%2Fimages%2Fasset-image-1-ui.png',
+                displayName: 'UI Screenshot'
+            })
+        }));
+        dispatchSpy.mockRestore();
+    });
+    it('falls back to opening gif attachments directly instead of dispatching annotate events', async () => {
+        const dispatchSpy = vi.spyOn(window, 'dispatchEvent').mockReturnValue(false);
+        const openSpy = vi.spyOn(window, 'open').mockImplementation(() => null);
+        const user = userEvent.setup();
+        const task = baseTask({
+            id: 'task-image-gif',
+            title: 'Task with gif attachment',
+            attachments: [
+                {
+                    path: '/api/taskforce/context/workspaces%2Fworkspace-1%2Fassets%2Fimages%2Fasset-image-anim.gif',
+                    fsPath: 'workspaces/workspace-1/assets/images/asset-image-anim.gif',
+                    assetId: 'asset-image-anim',
+                    displayName: 'Animated preview',
+                    originalFilename: 'animated.gif',
+                    caption: 'Animated preview',
+                }
+            ]
+        });
+        render(_jsx(TaskCard, { task: task, onClick: () => { }, onCopyId: () => { } }));
+        await user.click(screen.getByAltText('Attachment 0'));
+        expect(dispatchSpy).not.toHaveBeenCalledWith(expect.objectContaining({
+            type: 'taskforce:open-annotated-attachment',
+        }));
+        expect(openSpy).toHaveBeenCalledWith('/api/taskforce/context/workspaces%2Fworkspace-1%2Fassets%2Fimages%2Fasset-image-anim.gif', '_blank');
+        openSpy.mockRestore();
+        dispatchSpy.mockRestore();
+    });
+    it('uses the readable download filename for canonical document chips when metadata is still asset-like', () => {
+        const task = baseTask({
+            id: 'task-cloud-doc-download-name',
+            title: 'Task with asset-like cloud doc metadata',
+            attachments: [
+                {
+                    path: '/api/taskforce/documents/asset-6e00e54c659d4a8c90a930a8/content',
+                    fsPath: 'workspaces/workspace-1/assets/documents/asset-6e00e54c659d4a8c90a930a8-ai-profiles-plan.md',
+                    assetId: 'asset-6e00e54c659d4a8c90a930a8',
+                    displayName: 'asset-6e00e54c659d4a8c90a930a8',
+                    originalFilename: 'asset-6e00e54c659d4a8c90a930a8-ai-profiles-plan.md',
+                    caption: 'asset-6e00e54c659d4a8c90a930a8'
+                }
+            ]
+        });
+        render(_jsx(TaskCard, { task: task, onClick: () => { }, onCopyId: () => { } }));
+        const chipName = screen.getByText('ai profiles plan.md');
+        expect(chipName).toBeInTheDocument();
+        expect(screen.queryByText(/asset-6e00e54c659d4a8c90a930a8/i)).not.toBeInTheDocument();
+    });
+    it('prefers attachment captions over raw path filenames for document chips', () => {
+        const task = baseTask({
+            id: 'task-caption-context',
+            title: 'Task with captioned context',
+            attachments: [
+                {
+                    path: '/api/taskforce/context/task-data%2Ftask-caption-context%2Fattachments%2Fquarterly-financial-statement-2026.bin',
+                    fsPath: '.taskforce/task-data/task-caption-context/attachments/quarterly-financial-statement-2026.pdf',
+                    caption: 'Q1 board packet.pdf'
+                }
+            ]
+        });
+        render(_jsx(TaskCard, { task: task, onClick: () => { }, onCopyId: () => { } }));
+        expect(screen.getByText('Q1 board packet.pdf')).toBeInTheDocument();
+        expect(screen.queryByText(/quarterly-financial-statement/i)).not.toBeInTheDocument();
+        expect(screen.getByText('PDF')).toBeInTheDocument();
+    });
+    it('preserves image attachments as thumbnails', () => {
+        const task = baseTask({
+            id: 'task-image-context',
+            title: 'Task with image context',
+            attachments: [
+                '/api/taskforce/context/task-data%2Ftask-image-context%2Fattachments%2Fmock.png'
+            ]
+        });
+        render(_jsx(TaskCard, { task: task, onClick: () => { }, onCopyId: () => { } }));
+        expect(screen.getByRole('img', { name: 'Attachment 0' })).toBeInTheDocument();
+        expect(screen.queryByText('PNG')).not.toBeInTheDocument();
+    });
+    it('treats synced image attachments as thumbnails when only fsPath/originalFilename reveals the extension', () => {
+        const task = baseTask({
+            id: 'task-synced-image-context',
+            title: 'Task with synced image context',
+            attachments: [
+                {
+                    path: '/api/taskforce/context/workspaces%2Fworkspace-1%2Fassets%2Fimages%2Fasset-image-1',
+                    fsPath: 'workspaces/workspace-1/assets/images/asset-image-1-proof.png',
+                    originalFilename: 'proof.png',
+                    caption: 'Proof'
+                }
+            ]
+        });
+        render(_jsx(TaskCard, { task: task, onClick: () => { }, onCopyId: () => { } }));
+        expect(screen.getByRole('img', { name: 'Attachment 0' })).toBeInTheDocument();
+        expect(screen.queryByRole('button', { name: /proof png/i })).not.toBeInTheDocument();
     });
-    it('renders full ancestor chain (parent, grandparent, great-grandparent and above)', () => {
-        const root = baseTask({ id: 'task-root', title: 'Root' });
-        const greatGrand = baseTask({ id: 'task-great-grand', title: 'Great Grand', parentTaskId: root.id });
-        const grand = baseTask({ id: 'task-grand', title: 'Grand', parentTaskId: greatGrand.id });
-        const parent = baseTask({ id: 'task-parent-chain', title: 'Parent', parentTaskId: grand.id });
-        const leaf = baseTask({ id: 'task-leaf', title: 'Leaf', parentTaskId: parent.id });
-        render(_jsx(TaskCard, { task: leaf, allTasks: [leaf, parent, grand, greatGrand, root], onClick: () => { }, onCopyId: () => { } }));
-        expect(screen.getByText('Parent')).toBeInTheDocument();
-        expect(screen.getByText('Grand')).toBeInTheDocument();
-        expect(screen.getByText('Great Grand')).toBeInTheDocument();
-        expect(screen.getByText('Root')).toBeInTheDocument();
+    it('renders image attachments before document attachments and keeps images side by side', () => {
+        const task = baseTask({
+            id: 'task-mixed-context',
+            title: 'Task with mixed context',
+            attachments: [
+                {
+                    path: '/api/taskforce/context/task-data%2Ftask-mixed-context%2Fattachments%2Fnotes.bin',
+                    fsPath: '.taskforce/task-data/task-mixed-context/attachments/notes.md',
+                    caption: 'notes.md'
+                },
+                '/api/taskforce/context/task-data%2Ftask-mixed-context%2Fattachments%2Fimage-a.png',
+                '/api/taskforce/context/task-data%2Ftask-mixed-context%2Fattachments%2Fimage-b.png'
+            ]
+        });
+        const { container } = render(_jsx(TaskCard, { task: task, onClick: () => { }, onCopyId: () => { } }));
+        const firstImage = screen.getByRole('img', { name: 'Attachment 1' });
+        const secondImage = screen.getByRole('img', { name: 'Attachment 2' });
+        const documentButton = screen.getByRole('button', { name: /notes\.md md/i });
+        const imageRow = container.querySelector('[class*="attachmentImageRow"]');
+        expect(imageRow?.children).toHaveLength(2);
+        expect(firstImage.compareDocumentPosition(documentButton) & Node.DOCUMENT_POSITION_FOLLOWING).toBeTruthy();
+        expect(secondImage.compareDocumentPosition(documentButton) & Node.DOCUMENT_POSITION_FOLLOWING).toBeTruthy();
+    });
+    it('keeps the full filename in the chip title for long document names', () => {
+        const longName = 'multi-quarter-product-strategy-readout-final-v12-for-exec-review.md';
+        const task = baseTask({
+            id: 'task-long-context',
+            title: 'Task with long named context',
+            attachments: [
+                {
+                    path: '/api/taskforce/context/task-data%2Ftask-long-context%2Fattachments%2Flong-name.bin',
+                    fsPath: `.taskforce/task-data/task-long-context/attachments/${longName}`,
+                    caption: longName
+                }
+            ]
+        });
+        render(_jsx(TaskCard, { task: task, onClick: () => { }, onCopyId: () => { } }));
+        expect(screen.getByRole('button', { name: new RegExp(longName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'i') })).toHaveAttribute('title', longName);
+    });
+    it('renders the formatted task reference instead of an internal id suffix', () => {
+        const task = baseTask({
+            id: 'task-019d0159-2adb-7ee9-a264-bb819f0c6304',
+            referenceNumber: 123,
+            referenceLabel: 'T-123',
+            title: 'Reference Task'
+        });
+        render(_jsx(TaskCard, { task: task, onClick: () => { }, onCopyId: () => { } }));
+        expect(screen.getByRole('button', { name: /t-123/i })).toBeInTheDocument();
+        expect(screen.queryByText('019d0159')).not.toBeInTheDocument();
+    });
+    it('renders actual newline paragraphs without showing escaped newline text', () => {
+        const task = baseTask({
+            id: 'task-description-newlines',
+            title: 'Task with paragraphs',
+            description: 'Phase 1\n\nPhase 2'
+        });
+        const { container } = render(_jsx(TaskCard, { task: task, onClick: () => { }, onCopyId: () => { } }));
+        expect(screen.getByText('Phase 1')).toBeInTheDocument();
+        expect(screen.getByText('Phase 2')).toBeInTheDocument();
+        expect(container.textContent).not.toContain('\\n\\n');
+    });
+    it('hides retired custom taxonomies on cards when the task does not use them', () => {
+        const task = baseTask({
+            id: 'task-without-retired-taxonomy',
+            title: 'Task without retired taxonomy value'
+        });
+        render(_jsx(TaskCard, { task: task, taxonomies: [
+                {
+                    id: 'review-status',
+                    label: 'Review Status',
+                    status: 'retired',
+                    widgetType: 'select',
+                    isSystem: false,
+                    multiSelect: false,
+                    options: [{ value: 'pending', label: 'Pending', status: 'active' }]
+                }
+            ], onClick: () => { }, onCopyId: () => { } }));
+        expect(screen.queryByTitle(/Review Status/)).not.toBeInTheDocument();
+    });
+    it('keeps retired custom taxonomies visible on cards when the task uses them', () => {
+        const task = baseTask({
+            id: 'task-with-retired-taxonomy',
+            title: 'Task with retired taxonomy value',
+            taxonomies: { 'review-status': 'legacy' }
+        });
+        render(_jsx(TaskCard, { task: task, taxonomies: [
+                {
+                    id: 'review-status',
+                    label: 'Review Status',
+                    status: 'retired',
+                    widgetType: 'select',
+                    isSystem: false,
+                    multiSelect: false,
+                    options: [{ value: 'legacy', label: 'Legacy Review', status: 'retired', icon: 'Layers', color: '#7c3aed' }]
+                }
+            ], onClick: () => { }, onCopyId: () => { } }));
+        expect(screen.getByTitle('Review Status (Retired): Legacy Review (Retired)')).toBeInTheDocument();
     });
 });

package/dist/components/task/TaskContextUpload.d.ts

@@ -1,10 +1,11 @@
-import type { ScreenshotItem } from '../../types';
+import type { AttachmentItem } from '../../types';
 interface TaskContextUploadProps {
     taskId?: string | null;
-    contextFiles: Array<string | ScreenshotItem>;
-    browsedPath?: string;
-    onBrowseLinkPath?: () => void;
-    onAddContextFile: (file: ScreenshotItem) => void;
+    taskReferenceLabel?: string | null;
+    workspaceId?: string | null;
+    apiBaseUrl?: string;
+    contextFiles: Array<string | AttachmentItem>;
+    onAddContextFile: (file: AttachmentItem) => void;
     onRemoveContextFile: (index: number) => void;
     onUpdateContextCaption: (index: number, caption: string) => void;
 }