@taskforcehq/taskforce 0.3.170 → 0.3.301

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

@@ -14,16 +14,16 @@ describe('TaskForm Component', () => {
         priority: 2,
         complexity: 3,
         approach: '',
-        assignee: 'agent',
+        assignee: 'unassigned',
         scheduledDate: '',
         dueDate: '',
-        selectedSpecialists: [],
+        workstreamInput: '',
+        checklistItems: [],
         comments: [],
         newCommentText: '',
         contextFiles: [],
         descriptionFocused: false,
         showMarkdownHelp: false,
-        showSpecialists: false,
         showComments: false,
         showCategoryManager: false,
         showTypeManager: false,
@@ -31,13 +31,34 @@ describe('TaskForm Component', () => {
         formTaxonomies: {},
         taxonomies: [],
         approaches: [],
+        assigneeOptions: [
+            { value: 'unassigned', label: 'Unassigned', icon: 'HelpCircle', color: 'var(--text-secondary)', kind: 'unassigned' },
+            { value: 'member-1', label: 'Alex Example', icon: 'User', color: '#22c55e', kind: 'member' },
+        ],
         categories: [
             { value: 'general', label: 'General', disabled: false },
             { value: 'backend', label: 'Backend', disabled: false }
         ],
         types: [{ value: 'feature', label: 'Feature' }, { value: 'bug', label: 'Bug' }],
         priorities: [{ value: 3, label: 'High' }, { value: 2, label: 'Medium' }],
-        availableSpecialists: [{ value: 'qa', label: 'QA' }, { value: 'security', label: 'Security' }],
+        workstreams: [
+            {
+                id: 'workstream-1',
+                referenceNumber: 12,
+                referenceLabel: 'WS-12',
+                title: 'Platform Refinement',
+                description: null,
+                createdAt: '2026-04-03T00:00:00.000Z',
+            },
+            {
+                id: 'workstream-2',
+                referenceNumber: 44,
+                referenceLabel: 'WS-44',
+                title: 'Growth Experiments',
+                description: null,
+                createdAt: '2026-04-03T00:00:00.000Z',
+            },
+        ],
         copiedId: null,
         // Callbacks
         onTitleChange: vi.fn(),
@@ -50,11 +71,11 @@ describe('TaskForm Component', () => {
         onAssigneeChange: vi.fn(),
         onScheduledDateChange: vi.fn(),
         onDueDateChange: vi.fn(),
-        onSelectedSpecialistsChange: vi.fn(),
+        onWorkstreamInputChange: vi.fn(),
+        onChecklistItemsChange: vi.fn(),
         onNewCommentTextChange: vi.fn(),
         onDescriptionFocusedChange: vi.fn(),
         onShowMarkdownHelpChange: vi.fn(),
-        onShowSpecialistsChange: vi.fn(),
         onShowCommentsChange: vi.fn(),
         onShowCategoryManagerChange: vi.fn(),
         onShowTypeManagerChange: vi.fn(),
@@ -104,6 +125,15 @@ describe('TaskForm Component', () => {
         await user.type(textarea, 'Details');
         expect(defaultProps.onDescriptionChange).toHaveBeenCalled();
     });
+    it('renders actual newline paragraphs in description preview without escaped text', () => {
+        const { container } = renderForm({
+            description: 'Phase 1\n\nPhase 2',
+            descriptionFocused: false
+        });
+        expect(screen.getByText('Phase 1')).toBeInTheDocument();
+        expect(screen.getByText('Phase 2')).toBeInTheDocument();
+        expect(container.textContent).not.toContain('\\n\\n');
+    });
     it('3.5 Category selection', async () => {
         const user = userEvent.setup();
         renderForm();
@@ -113,6 +143,32 @@ describe('TaskForm Component', () => {
         await user.click(option);
         expect(defaultProps.onCategoryChange).toHaveBeenCalledWith('backend');
     });
+    it('keeps a legacy category selectable when the current task already uses it', async () => {
+        const user = userEvent.setup();
+        renderForm({
+            category: 'backend',
+            categories: [
+                { value: 'default', label: 'General', disabled: false },
+                { value: 'backend', label: 'Backend', disabled: true }
+            ]
+        });
+        const dropdown = screen.getByRole('combobox', { name: /category/i });
+        await user.click(dropdown);
+        expect(screen.getAllByText('Backend (Legacy)').length).toBeGreaterThan(0);
+    });
+    it('uses the configured default category label in the category picker', async () => {
+        const user = userEvent.setup();
+        renderForm({
+            categories: [
+                { value: 'default', label: 'Inbox Work', icon: 'Star', color: 'teal-500', disabled: false },
+                { value: 'backend', label: 'Backend', disabled: false }
+            ]
+        });
+        const dropdown = screen.getByRole('combobox', { name: /category/i });
+        await user.click(dropdown);
+        expect(screen.getByText('Inbox Work')).toBeInTheDocument();
+        expect(screen.queryByText('General')).not.toBeInTheDocument();
+    });
     it('3.6 Type selection', async () => {
         const user = userEvent.setup();
         renderForm();
@@ -122,6 +178,19 @@ describe('TaskForm Component', () => {
         await user.click(option);
         expect(defaultProps.onTypeChange).toHaveBeenCalledWith('bug');
     });
+    it('keeps a retired type selectable when the current task already uses it', async () => {
+        const user = userEvent.setup();
+        renderForm({
+            type: 'issue',
+            types: [
+                { value: 'task', label: 'Task', status: 'active' },
+                { value: 'issue', label: 'Issue', status: 'retired' }
+            ]
+        });
+        const dropdown = screen.getByRole('combobox', { name: /type/i });
+        await user.click(dropdown);
+        expect(screen.getAllByText('Issue (Retired)').length).toBeGreaterThan(0);
+    });
     it('3.7 Priority selection', () => {
         renderForm();
         // LevelSelector uses divs/buttons. Looking at LevelSelector implementation (implied):
@@ -131,13 +200,150 @@ describe('TaskForm Component', () => {
         fireEvent.click(priorityOption);
         expect(defaultProps.onPriorityChange).toHaveBeenCalledWith(3);
     });
-    it('3.9 Specialists selection', async () => {
+    it('renders workspace member assignee options', async () => {
         const user = userEvent.setup();
-        renderForm({ showSpecialists: true });
-        const specialistBtn = screen.getByText('QA');
-        await user.click(specialistBtn);
-        // It passes the new array. Initially empty, so now ['qa']
-        expect(defaultProps.onSelectedSpecialistsChange).toHaveBeenCalledWith(['qa']);
+        renderForm();
+        const dropdown = screen.getByRole('combobox', { name: /assigned to/i });
+        await user.click(dropdown);
+        expect(screen.getByText('Alex Example')).toBeInTheDocument();
+    });
+    it('shows attach to workstream only on the new task form', () => {
+        renderForm();
+        expect(screen.getByText('Attach to workstream')).toBeInTheDocument();
+        expect(screen.getByRole('combobox', { name: /attach to workstream/i })).toBeInTheDocument();
+    });
+    it('does not show attach to workstream on the edit task form', () => {
+        renderForm({
+            editingTaskId: 'task-1',
+            currentTask: {
+                id: 'task-1',
+                title: 'Existing task',
+                description: '',
+                category: 'general',
+                type: 'feature',
+                priority: 2,
+                status: 'task',
+                createdAt: '2026-04-03T00:00:00.000Z',
+            }
+        });
+        expect(screen.queryByText('Attach to workstream')).not.toBeInTheDocument();
+    });
+    it('switches the create-workstream control into manual entry when plus is clicked', async () => {
+        const user = userEvent.setup();
+        renderForm();
+        await user.click(screen.getByRole('button', { name: /enter workstream by name/i }));
+        const manualInput = screen.getByRole('textbox', { name: /attach to workstream/i });
+        expect(manualInput).toBeInTheDocument();
+        await user.type(manualInput, 'Platform Refinement');
+        expect(defaultProps.onWorkstreamInputChange).toHaveBeenCalled();
+    });
+    it('renders custom taxonomy descriptions as helper text', () => {
+        renderForm({
+            taxonomies: [{
+                    id: 'review-status',
+                    label: 'Review Status',
+                    description: 'Use this to track review routing.',
+                    widgetType: 'select',
+                    isSystem: false,
+                    multiSelect: false,
+                    options: [{ value: 'pending', label: 'Pending', status: 'active' }]
+                }]
+        });
+        expect(screen.getByText('Use this to track review routing.')).toBeInTheDocument();
+    });
+    it('hides custom taxonomies from the task form when form visibility is disabled', () => {
+        renderForm({
+            taxonomies: [{
+                    id: 'review-status',
+                    label: 'Review Status',
+                    formEnabled: false,
+                    widgetType: 'select',
+                    isSystem: false,
+                    multiSelect: false,
+                    options: [{ value: 'pending', label: 'Pending', status: 'active' }]
+                }]
+        });
+        expect(screen.queryByText('Review Status')).not.toBeInTheDocument();
+    });
+    it('keeps a hidden custom taxonomy visible when the current task already has a value', () => {
+        renderForm({
+            formTaxonomies: { 'review-status': 'pending' },
+            taxonomies: [{
+                    id: 'review-status',
+                    label: 'Review Status',
+                    formEnabled: false,
+                    widgetType: 'select',
+                    isSystem: false,
+                    multiSelect: false,
+                    options: [{ value: 'pending', label: 'Pending', status: 'active' }]
+                }]
+        });
+        expect(screen.getByText('Review Status')).toBeInTheDocument();
+    });
+    it('renders multi-select custom taxonomies as selectable chips', async () => {
+        const user = userEvent.setup();
+        renderForm({
+            taxonomies: [{
+                    id: 'channels',
+                    label: 'Channels',
+                    widgetType: 'select',
+                    isSystem: false,
+                    multiSelect: true,
+                    options: [
+                        { value: 'email', label: 'Email', status: 'active' },
+                        { value: 'social', label: 'Social', status: 'active' }
+                    ]
+                }]
+        });
+        await user.click(screen.getByRole('button', { name: 'Email' }));
+        expect(defaultProps.onTaxonomyChange).toHaveBeenCalledWith('channels', ['email']);
+    });
+    it('keeps selected retired multi-select custom taxonomy options available', () => {
+        renderForm({
+            formTaxonomies: { channels: ['email'] },
+            taxonomies: [{
+                    id: 'channels',
+                    label: 'Channels',
+                    widgetType: 'select',
+                    isSystem: false,
+                    multiSelect: true,
+                    options: [
+                        { value: 'email', label: 'Email', status: 'retired' },
+                        { value: 'social', label: 'Social', status: 'active' }
+                    ]
+                }]
+        });
+        expect(screen.getByRole('button', { name: /Email \(Retired\)/i })).toBeInTheDocument();
+        expect(screen.getByRole('button', { name: 'Social' })).toBeInTheDocument();
+    });
+    it('hides retired custom taxonomies from new-task entry when there is no selected value', () => {
+        renderForm({
+            taxonomies: [{
+                    id: 'channels',
+                    label: 'Channels',
+                    status: 'retired',
+                    widgetType: 'select',
+                    isSystem: false,
+                    multiSelect: false,
+                    options: [{ value: 'email', label: 'Email', status: 'active' }]
+                }]
+        });
+        expect(screen.queryByText('Channels')).not.toBeInTheDocument();
+    });
+    it('keeps retired custom taxonomies visible when the current task already has a value', () => {
+        renderForm({
+            formTaxonomies: { channels: 'email' },
+            taxonomies: [{
+                    id: 'channels',
+                    label: 'Channels',
+                    status: 'retired',
+                    widgetType: 'select',
+                    isSystem: false,
+                    multiSelect: false,
+                    options: [{ value: 'email', label: 'Email', status: 'active' }]
+                }]
+        });
+        expect(screen.getByText('Channels')).toBeInTheDocument();
     });
     // --- Edit Task Tests ---
     it('3.10 Load existing task', () => {
@@ -154,6 +360,46 @@ describe('TaskForm Component', () => {
         renderForm();
         expect(screen.getByPlaceholderText('What needs to be done?')).toBeInTheDocument();
     });
+    it('renders assignee audit activity with readable labels instead of raw ids', () => {
+        renderForm({
+            editingTaskId: '123',
+            showComments: true,
+            assigneeOptions: [
+                ...defaultProps.assigneeOptions,
+                { value: 'ai-profile-1', label: 'Planner Bot', icon: 'Bot', color: '#8b5cf6', kind: 'agent' },
+            ],
+            currentTask: {
+                id: '123',
+                title: 'Existing Task',
+                activity: [
+                    {
+                        id: 'event:task-event-1',
+                        type: 'event',
+                        timestamp: '2026-03-23T12:00:00.000Z',
+                        event: {
+                            id: 'task-event-1',
+                            taskId: '123',
+                            workspaceId: 'workspace-1',
+                            action: 'task-updated',
+                            actor: 'member-1',
+                            actorType: 'human',
+                            createdAt: '2026-03-23T12:00:00.000Z',
+                            details: {
+                                changes: {
+                                    assignee: {
+                                        from: 'unassigned',
+                                        to: 'ai-profile-1',
+                                    },
+                                },
+                            },
+                        },
+                    },
+                ],
+            },
+        });
+        expect(screen.getByText('assignee: Unassigned -> Planner Bot')).toBeInTheDocument();
+        expect(screen.queryByText(/ai-profile-1/i)).not.toBeInTheDocument();
+    });
     it('3.13 Update title', async () => {
         const user = userEvent.setup();
         renderForm({ editingTaskId: '123', title: 'Old Title' });
@@ -162,19 +408,18 @@ describe('TaskForm Component', () => {
         await user.type(input, 'New Title');
         expect(defaultProps.onTitleChange).toHaveBeenCalled();
     });
-    it('disables scheduled date for parent tasks', () => {
+    it('keeps scheduled date editable in the task form', () => {
         renderForm({
             editingTaskId: 'parent-1',
             currentTask: { id: 'parent-1', title: 'Parent Task' },
-            currentTaskChildren: [{ id: 'child-1', title: 'Child Task' }]
         });
         const scheduledLabel = screen.getByText('Scheduled:');
         const scheduledInput = scheduledLabel.nextElementSibling;
         expect(scheduledInput).toBeTruthy();
         if (!scheduledInput)
             throw new Error('Scheduled date input missing');
-        expect(scheduledInput.disabled).toBe(true);
-        expect(screen.getByText('Parent tasks cannot be scheduled. Schedule leaf tasks instead.')).toBeInTheDocument();
+        expect(scheduledInput.disabled).toBe(false);
+        expect(screen.queryByText('Parent tasks cannot be scheduled. Schedule leaf tasks instead.')).not.toBeInTheDocument();
     });
     it('3.14 Context Documents section renders', async () => {
         const user = userEvent.setup();
@@ -197,13 +442,6 @@ describe('TaskForm Component', () => {
         fireEvent.click(previewDiv);
         expect(defaultProps.onDescriptionFocusedChange).toHaveBeenCalledWith(true);
     });
-    it('3.17 Specialists Toggle', async () => {
-        const user = userEvent.setup();
-        renderForm({ availableSpecialists: [{ value: 'qa', label: 'QA' }] });
-        const toggle = screen.getByTitle('Show all specialists');
-        await user.click(toggle);
-        expect(defaultProps.onShowSpecialistsChange).toHaveBeenCalledWith(true);
-    });
     it('3.18 Category Manager Toggle', async () => {
         const user = userEvent.setup();
         renderForm();
@@ -268,6 +506,164 @@ describe('TaskForm Component', () => {
         await user.click(button);
         expect(defaultProps.onAddComment).toHaveBeenCalled();
     });
+    it('renders named AI comment authors from resolved actor data', () => {
+        renderForm({
+            editingTaskId: '123',
+            showComments: true,
+            comments: [
+                {
+                    id: 'comment-1',
+                    author: 'ai-profile-123',
+                    text: 'I reviewed the task details.',
+                    timestamp: '2026-03-22T10:00:00.000Z',
+                    actor: {
+                        id: 'ai-profile-123',
+                        kind: 'ai',
+                        label: 'Codex',
+                        username: 'codex',
+                        icon: 'Bot',
+                        color: '#0ea5e9',
+                        isNamed: true,
+                    },
+                },
+            ],
+        });
+        expect(screen.getByText('Codex')).toBeInTheDocument();
+        expect(screen.queryByText('AI Agent')).not.toBeInTheDocument();
+    });
+    it('renders task audit events in the activity feed', () => {
+        renderForm({
+            editingTaskId: '123',
+            showComments: true,
+            currentTask: {
+                id: 'task-activity-1',
+                title: 'Activity Task',
+                status: 'in-progress',
+                createdAt: '2026-03-22T09:00:00.000Z',
+                activity: [
+                    {
+                        id: 'event:1',
+                        type: 'event',
+                        timestamp: '2026-03-22T10:00:00.000Z',
+                        event: {
+                            id: 'event-1',
+                            taskId: 'task-activity-1',
+                            workspaceId: 'default',
+                            action: 'task-status-changed',
+                            actor: 'user',
+                            actorType: 'human',
+                            createdAt: '2026-03-22T10:00:00.000Z',
+                            details: {
+                                changes: {
+                                    status: { from: 'task', to: 'in-progress' }
+                                }
+                            }
+                        }
+                    }
+                ]
+            },
+        });
+        expect(screen.getByText('Status: task -> in-progress')).toBeInTheDocument();
+        expect(screen.queryByText('System')).not.toBeInTheDocument();
+    });
+    it('summarizes description audit events without rendering the full description body', () => {
+        renderForm({
+            editingTaskId: '123',
+            showComments: true,
+            currentTask: {
+                id: 'task-activity-2',
+                title: 'Description Audit Task',
+                status: 'task',
+                createdAt: '2026-03-22T09:00:00.000Z',
+                activity: [
+                    {
+                        id: 'event:2',
+                        type: 'event',
+                        timestamp: '2026-03-22T10:00:00.000Z',
+                        event: {
+                            id: 'event-2',
+                            taskId: 'task-activity-2',
+                            workspaceId: 'default',
+                            action: 'task-updated',
+                            actor: 'user',
+                            actorType: 'human',
+                            createdAt: '2026-03-22T10:00:00.000Z',
+                            details: {
+                                changes: {
+                                    description: {
+                                        from: '',
+                                        to: 'Line one\n\nLine two\n\nLine three'
+                                    }
+                                }
+                            }
+                        }
+                    }
+                ]
+            },
+        });
+        expect(screen.getByText('Description added')).toBeInTheDocument();
+        expect(screen.queryByText(/Line one/)).not.toBeInTheDocument();
+        expect(screen.queryByText(/Line two/)).not.toBeInTheDocument();
+        expect(screen.queryByText(/Line three/)).not.toBeInTheDocument();
+    });
+    it('falls back to the current task actor label for AI comments when only the id is present', () => {
+        renderForm({
+            editingTaskId: '123',
+            showComments: true,
+            currentTask: {
+                id: '123',
+                title: 'Codex-owned task',
+                assignee: 'ai-profile-123',
+                assigneeActor: {
+                    id: 'ai-profile-123',
+                    kind: 'ai',
+                    label: 'Codex',
+                    username: 'codex',
+                    icon: 'Bot',
+                    color: '#0ea5e9',
+                    isNamed: true,
+                },
+            },
+            comments: [
+                {
+                    id: 'comment-2',
+                    author: 'ai-profile-123',
+                    text: 'Rendered from task actor fallback.',
+                    timestamp: '2026-03-22T10:05:00.000Z',
+                },
+            ],
+        });
+        expect(screen.getByText('Codex')).toBeInTheDocument();
+        expect(screen.queryByText(/019d|ai-profile/i)).not.toBeInTheDocument();
+    });
+    it('uses the resolved actor icon and color tint for named AI comments', () => {
+        const { container } = renderForm({
+            editingTaskId: '123',
+            showComments: true,
+            comments: [
+                {
+                    id: 'comment-3',
+                    author: 'claude',
+                    text: 'Resolved actor presentation.',
+                    timestamp: '2026-03-22T10:10:00.000Z',
+                    actor: {
+                        id: 'ai-profile-claude',
+                        kind: 'ai',
+                        label: 'Claude',
+                        username: 'claude',
+                        icon: 'Bot',
+                        color: '#f59e0b',
+                        isNamed: true,
+                    },
+                },
+            ],
+        });
+        expect(container.querySelector('.lucide-bot')).toBeTruthy();
+        const bubble = screen.getByText('Resolved actor presentation.').closest('[class*="commentText"]');
+        expect(bubble).toHaveStyle({
+            borderColor: 'rgba(245, 158, 11, 0.35)',
+        });
+    });
     // --- Context Upload ---
     it('3.25 Render context image', async () => {
         const user = userEvent.setup();

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

@@ -1,5 +1,7 @@
 import React from 'react';
-import type { TaskItem, CategoryConfig, TaxonomyDefinition, PriorityDefinition, TaskAssignee } from '../../types';
+import type { TaskItem, CategoryConfig, TaxonomyDefinition, PriorityDefinition, TaskAssignee, WorkstreamItem, InitiativeItem } from '../../types';
+import type { TaskAssigneeOption } from '../../utils/assignees';
+import { type TaskSortKey } from '../../utils/taxonomySorting.js';
 export interface KanbanColumnDef {
     value: string | number;
     label: string;
@@ -13,16 +15,17 @@ type ScheduleDayKey = 'mon' | 'tue' | 'wed' | 'thu' | 'fri' | 'sat' | 'sun';
 interface TaskKanbanProps {
     tasks: TaskItem[];
     allTasks?: TaskItem[];
-    hierarchyTasks?: TaskItem[];
     columns: KanbanColumnDef[];
-    groupBy: 'category' | 'type' | 'priority' | 'approach' | 'assignee' | 'status' | 'complexity' | 'hierarchy' | 'schedule';
+    groupBy: 'category' | 'type' | 'priority' | 'approach' | 'assignee' | 'status' | 'complexity' | 'schedule';
     searchQuery?: string;
     copiedId?: string | null;
-    availableSpecialists?: {
+    taxonomies?: TaxonomyDefinition[];
+    types?: Array<{
         value: string;
         label: string;
-    }[];
-    taxonomies?: TaxonomyDefinition[];
+        color?: string;
+        icon?: string;
+    }>;
     priorities?: PriorityDefinition[];
     approaches?: Array<{
         value: string;
@@ -30,6 +33,7 @@ interface TaskKanbanProps {
         color?: string;
         icon?: string;
     }>;
+    assigneeOptions?: TaskAssigneeOption[];
     onUpdateTask: (id: string, updates: Partial<TaskItem>) => void;
     onTaskClick: (task: TaskItem) => void;
     onOpenTaskById?: (taskId: string) => void;
@@ -38,11 +42,10 @@ interface TaskKanbanProps {
     onToggleReview?: (task: TaskItem) => void;
     onToggleComplete?: (task: TaskItem) => void;
     onToggleCancel?: (task: TaskItem) => void;
+    onSetStatus?: (task: TaskItem, status: TaskItem['status']) => void;
     onArchiveTask?: (task: TaskItem) => void;
     onUnarchive?: (id: string) => void;
     onDelete?: (id: string) => void;
-    onUnlinkChildTask?: (taskId: string) => void;
-    onClearParentTask?: (taskId: string) => void;
     onAddTaskToColumn?: (groupBy: string, value: string | number) => void;
     emptyColumnMode?: 'show' | 'collapse' | 'hide';
     filterCategories?: string[];
@@ -50,27 +53,23 @@ interface TaskKanbanProps {
     filterPriorities?: number[];
     filterStatus?: string[];
     filterAssignees?: TaskAssignee[];
-    assigneeFilterEnabled?: boolean;
     scheduleFilteredTaskIds?: string[];
     categories?: CategoryConfig[];
     compressed?: boolean;
+    readOnlyMode?: 'archived' | 'deleted' | null;
     recentlyChangedTaskIds?: string[];
     scheduleDates?: Partial<Record<ScheduleDayKey, string>>;
     onScheduleDaySelected?: (date: string) => void;
-    onScheduleParentDrop?: (payload: {
-        parentTaskId: string;
-        parentTitle: string;
-        targetColumn: ScheduleDayKey;
-        targetDate: string;
-        toScheduleLeafTaskIds: string[];
-        alreadyScheduledLeafCount: number;
-        totalLeafDescendants: number;
-    }) => void;
-    hierarchyChildOrderMode?: 'manual' | 'auto';
     persistedScrollLeft?: number;
     onScrollLeftChange?: (scrollLeft: number) => void;
-    sortBy?: 'created' | 'priority' | 'updated' | 'complexity';
+    sortBy?: TaskSortKey;
     sortOrder?: 'asc' | 'desc';
+    planningDropTargets?: React.ReactNode;
+    onAssignTaskToWorkstream?: (taskId: string, workstreamId: string | null) => void | Promise<void>;
+    onAssignWorkstreamToInitiative?: (workstreamId: string, initiativeId: string | null) => void | Promise<void>;
+    showTaskCardStatusLabel?: boolean;
+    workstreams?: WorkstreamItem[];
+    initiatives?: InitiativeItem[];
 }
-export declare function TaskKanban({ tasks, columns: kanbanColumns, groupBy, searchQuery, copiedId, availableSpecialists, taxonomies, priorities, approaches, onUpdateTask, onTaskClick, onOpenTaskById, onCopyId, onToggleInProgress, onToggleReview, onToggleComplete, onToggleCancel, onArchiveTask, onUnarchive, onDelete, onUnlinkChildTask, onClearParentTask, allTasks, hierarchyTasks, onAddTaskToColumn, emptyColumnMode, filterCategories, filterTypes, filterPriorities, filterStatus, filterAssignees, assigneeFilterEnabled, scheduleFilteredTaskIds, categories, compressed, recentlyChangedTaskIds, scheduleDates, onScheduleDaySelected, onScheduleParentDrop, hierarchyChildOrderMode, persistedScrollLeft, onScrollLeftChange, sortBy, sortOrder }: TaskKanbanProps): import("react/jsx-runtime").JSX.Element;
+export declare function TaskKanban({ tasks, columns: kanbanColumns, groupBy, searchQuery, copiedId, taxonomies, types, priorities, approaches, assigneeOptions, onUpdateTask, onTaskClick, onOpenTaskById, onCopyId, onToggleInProgress, onToggleReview, onToggleComplete, onToggleCancel, onSetStatus, onArchiveTask, onUnarchive, onDelete, allTasks, onAddTaskToColumn, emptyColumnMode, filterCategories, filterTypes, filterPriorities, filterStatus, filterAssignees, scheduleFilteredTaskIds, categories, compressed, readOnlyMode, recentlyChangedTaskIds, scheduleDates, onScheduleDaySelected, persistedScrollLeft, onScrollLeftChange, sortBy, sortOrder, planningDropTargets, onAssignTaskToWorkstream, onAssignWorkstreamToInitiative, showTaskCardStatusLabel, workstreams, initiatives, }: TaskKanbanProps): import("react/jsx-runtime").JSX.Element;
 export {};