@taskforcehq/taskforce 0.3.324 → 0.3.327

package/dist/components/task/TaskWorkflowAssignmentField.js

@@ -0,0 +1,362 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import React from 'react';
+import { Check, CheckCircle, ChevronDown, ChevronRight, Circle, LoaderCircle, PlayCircle, RotateCcw } from 'lucide-react';
+import styles from '../../Taskforce.module.css';
+import formStyles from './TaskForm.module.css';
+import { TaxonomyDropdown } from '../ui/TaxonomyDropdown.js';
+import { assignWorkflowToTask, completeCurrentWorkflowStep, getTaskWorkflowAssignment, listWorkflowTemplates, removePendingTaskWorkflow, replacePendingTaskWorkflow, } from '../features/workflowManager/workflowManagerApi.js';
+import { getAssigneeLabel } from '../../utils/assignees.js';
+import { TASKFORCE_TASKS_MUTATED_EVENT, } from '../../utils/taskEvents.js';
+const NO_WORKFLOW = '__none__';
+function statusLabel(status) {
+    return status.charAt(0).toUpperCase() + status.slice(1);
+}
+export function TaskWorkflowAssignmentField({ taskId, workspaceId, taskStatus, taskUpdatedAt, comments = [], assigneeOptions = [], currentActorId, apiBaseUrl, runtimeMode = 'local', disabled = false, onActivatePendingWorkflow, onActiveOwnerChange, }) {
+    const [workflows, setWorkflows] = React.useState([]);
+    const [assignment, setAssignment] = React.useState(null);
+    const [loading, setLoading] = React.useState(true);
+    const [assigning, setAssigning] = React.useState(false);
+    const [completingStep, setCompletingStep] = React.useState(false);
+    const [executionExpanded, setExecutionExpanded] = React.useState(false);
+    const [activationRetryToken, setActivationRetryToken] = React.useState(0);
+    const [error, setError] = React.useState('');
+    const requestGenerationRef = React.useRef(0);
+    const activationAttemptRef = React.useRef(null);
+    const refreshedTaskRevisionRef = React.useRef({
+        taskId,
+        revision: `${taskId}:${taskUpdatedAt || ''}`,
+    });
+    const requestContext = React.useMemo(() => ({ workspaceId, apiBaseUrl, runtimeMode }), [apiBaseUrl, runtimeMode, workspaceId]);
+    React.useEffect(() => {
+        const requestGeneration = ++requestGenerationRef.current;
+        setLoading(true);
+        setAssigning(false);
+        setCompletingStep(false);
+        setError('');
+        setWorkflows([]);
+        setAssignment(null);
+        setExecutionExpanded(false);
+        setActivationRetryToken(0);
+        activationAttemptRef.current = null;
+        void Promise.allSettled([
+            listWorkflowTemplates(requestContext),
+            getTaskWorkflowAssignment(taskId, requestContext),
+        ]).then(([workflowResult, assignmentResult]) => {
+            if (requestGeneration !== requestGenerationRef.current)
+                return;
+            if (workflowResult.status === 'fulfilled') {
+                setWorkflows(workflowResult.value.filter((summary) => (summary.template.status === 'active' && Boolean(summary.latestPublishedVersion))));
+            }
+            if (assignmentResult.status === 'fulfilled') {
+                setAssignment(assignmentResult.value);
+            }
+            if (assignmentResult.status === 'rejected') {
+                setError(String(assignmentResult.reason?.message || 'Unable to load workflow assignment.'));
+            }
+            else if (!assignmentResult.value && workflowResult.status === 'rejected') {
+                setError(String(workflowResult.reason?.message || 'Unable to load workflows.'));
+            }
+            setLoading(false);
+        });
+        return () => { requestGenerationRef.current += 1; };
+    }, [requestContext, taskId]);
+    const latestAssignment = assignment?.execution.taskId === taskId ? assignment : null;
+    const hasActiveExecution = latestAssignment
+        ? ['pending', 'running', 'paused'].includes(latestAssignment.execution.status)
+        : false;
+    const activeAssignment = hasActiveExecution ? latestAssignment : null;
+    const selectableWorkflows = latestAssignment && !workflows.some(({ template }) => template.id === latestAssignment.template.id)
+        ? [{
+                template: latestAssignment.template,
+                draftVersionId: null,
+                latestPublishedVersion: {
+                    id: latestAssignment.version.id,
+                    versionNumber: latestAssignment.version.versionNumber,
+                    publishedAt: latestAssignment.version.publishedAt,
+                },
+            }, ...workflows]
+        : workflows;
+    const options = [
+        ...(!latestAssignment || hasActiveExecution ? [{ value: NO_WORKFLOW, label: 'None' }] : []),
+        ...selectableWorkflows.map(({ template }) => ({ value: template.id, label: template.name })),
+    ];
+    const isPending = activeAssignment?.execution.status === 'pending';
+    const canChange = !disabled && !loading && !assigning && (!activeAssignment || isPending);
+    const selectedValue = latestAssignment?.template.id || NO_WORKFLOW;
+    const orderedSteps = React.useMemo(() => [...(latestAssignment?.steps || [])].sort((a, b) => a.position - b.position), [latestAssignment?.steps]);
+    const currentStep = latestAssignment?.execution.currentStepId
+        ? orderedSteps.find((step) => step.id === latestAssignment.execution.currentStepId) || null
+        : null;
+    const currentStepIndex = latestAssignment?.execution.currentStepId
+        ? orderedSteps.findIndex((step) => step.id === latestAssignment.execution.currentStepId)
+        : -1;
+    const executionCompleted = latestAssignment?.execution.status === 'completed';
+    const completedStepIds = React.useMemo(() => new Set((latestAssignment?.events || [])
+        .filter((event) => event.eventType === 'step-completed' && event.stepId)
+        .map((event) => event.stepId)), [latestAssignment?.events]);
+    const pendingStartStepId = activeAssignment?.execution.status === 'pending'
+        ? (orderedSteps.find((step) => step.isRequired) || orderedSteps[0])?.id
+        : null;
+    const executionPanelId = `task-workflow-execution-${taskId}`;
+    const executionStatus = loading
+        ? 'Loading...'
+        : error && !latestAssignment
+            ? 'Unavailable'
+            : latestAssignment
+                ? statusLabel(latestAssignment.execution.status)
+                : 'Not assigned';
+    const executionVersion = latestAssignment?.version.versionNumber
+        ? `V${latestAssignment.version.versionNumber}`
+        : null;
+    const executionStatusForLabel = executionStatus.replace(/\.+$/, '');
+    const executionStatusAccessibleLabel = latestAssignment
+        ? `Status: ${executionStatusForLabel}${executionVersion ? `, ${executionVersion}` : ''}. ${executionExpanded ? 'Hide' : 'View'} workflow execution.`
+        : `Status: ${executionStatusForLabel}.`;
+    const canCompleteCurrentStep = !disabled
+        && !completingStep
+        && activeAssignment?.execution.status === 'running'
+        && currentStep?.ownerType === 'user'
+        && Boolean(currentActorId)
+        && currentStep.ownerId === currentActorId;
+    const rerunWorkflow = executionCompleted
+        ? workflows.find(({ template }) => template.id === latestAssignment?.template.id) || null
+        : null;
+    const canRerunWorkflow = Boolean(!disabled
+        && !assigning
+        && rerunWorkflow?.latestPublishedVersion);
+    React.useEffect(() => {
+        const executionId = activeAssignment?.execution.id || null;
+        if (!executionId
+            || activeAssignment?.execution.status !== 'pending'
+            || taskStatus !== 'in-progress'
+            || !onActivatePendingWorkflow
+            || activationAttemptRef.current === executionId)
+            return;
+        activationAttemptRef.current = executionId;
+        const requestGeneration = requestGenerationRef.current;
+        setAssigning(true);
+        setError('');
+        void Promise.resolve(onActivatePendingWorkflow()).then(async () => {
+            const activatedAssignment = await getTaskWorkflowAssignment(taskId, requestContext);
+            if (requestGeneration !== requestGenerationRef.current)
+                return;
+            if (activatedAssignment?.execution.status === 'pending') {
+                throw new Error('Workflow is still pending. Retry to start it.');
+            }
+            const activeStep = activatedAssignment?.steps.find((step) => step.id === activatedAssignment.execution.currentStepId);
+            if (activeStep?.ownerId)
+                onActiveOwnerChange?.(activeStep.ownerId);
+            setAssignment(activatedAssignment);
+        }).catch((requestError) => {
+            if (requestGeneration !== requestGenerationRef.current)
+                return;
+            activationAttemptRef.current = null;
+            setError(String(requestError?.message || 'Unable to start workflow.'));
+        }).finally(() => {
+            if (requestGeneration === requestGenerationRef.current)
+                setAssigning(false);
+        });
+    }, [
+        activationRetryToken,
+        activeAssignment,
+        onActivatePendingWorkflow,
+        onActiveOwnerChange,
+        requestContext,
+        taskId,
+        taskStatus,
+    ]);
+    const ownerLabel = React.useCallback((ownerId) => {
+        if (!ownerId)
+            return 'Unassigned';
+        return getAssigneeLabel(ownerId, assigneeOptions);
+    }, [assigneeOptions]);
+    React.useEffect(() => {
+        if (refreshedTaskRevisionRef.current.taskId !== taskId) {
+            refreshedTaskRevisionRef.current = {
+                taskId,
+                revision: `${taskId}:${taskUpdatedAt || ''}`,
+            };
+        }
+    }, [taskId, taskUpdatedAt]);
+    React.useEffect(() => {
+        const taskRevision = `${taskId}:${taskUpdatedAt || ''}`;
+        if (taskRevision === refreshedTaskRevisionRef.current.revision
+            || taskStatus !== 'in-progress'
+            || !isPending)
+            return;
+        refreshedTaskRevisionRef.current = { taskId, revision: taskRevision };
+        const requestGeneration = requestGenerationRef.current;
+        void getTaskWorkflowAssignment(taskId, requestContext).then((nextAssignment) => {
+            if (requestGeneration !== requestGenerationRef.current)
+                return;
+            setAssignment(nextAssignment);
+        }).catch((requestError) => {
+            if (requestGeneration !== requestGenerationRef.current)
+                return;
+            setError(String(requestError?.message || 'Unable to refresh workflow assignment.'));
+        });
+    }, [isPending, requestContext, taskId, taskStatus, taskUpdatedAt]);
+    React.useEffect(() => {
+        if (typeof window === 'undefined')
+            return;
+        const handleWorkflowStepMutation = (event) => {
+            const detail = event.detail;
+            if (detail?.reason !== 'workflow-step')
+                return;
+            const eventWorkspaceId = String(detail.workspaceId || '').trim();
+            const currentWorkspaceId = String(workspaceId || '').trim();
+            if (currentWorkspaceId && eventWorkspaceId !== currentWorkspaceId)
+                return;
+            const eventTaskId = String(detail.taskId || '').trim();
+            if (eventTaskId !== taskId)
+                return;
+            const requestGeneration = ++requestGenerationRef.current;
+            void getTaskWorkflowAssignment(taskId, requestContext).then((nextAssignment) => {
+                if (requestGeneration !== requestGenerationRef.current)
+                    return;
+                setAssignment(nextAssignment);
+                setError('');
+            }).catch((requestError) => {
+                if (requestGeneration !== requestGenerationRef.current)
+                    return;
+                setError(String(requestError?.message || 'Unable to refresh workflow assignment.'));
+            });
+        };
+        window.addEventListener(TASKFORCE_TASKS_MUTATED_EVENT, handleWorkflowStepMutation);
+        return () => window.removeEventListener(TASKFORCE_TASKS_MUTATED_EVENT, handleWorkflowStepMutation);
+    }, [requestContext, taskId, workspaceId]);
+    const handleChange = async (value) => {
+        const nextWorkflowId = String(value);
+        if (!canChange || nextWorkflowId === selectedValue)
+            return;
+        const requestGeneration = requestGenerationRef.current;
+        setAssigning(true);
+        setError('');
+        try {
+            if (nextWorkflowId === NO_WORKFLOW) {
+                await removePendingTaskWorkflow(taskId, requestContext);
+                if (requestGeneration !== requestGenerationRef.current)
+                    return;
+                setAssignment(null);
+                return;
+            }
+            const selectedWorkflow = workflows.find(({ template }) => template.id === nextWorkflowId);
+            const version = selectedWorkflow?.latestPublishedVersion;
+            if (!selectedWorkflow || !version)
+                return;
+            const assignmentInput = {
+                workflowTemplateId: selectedWorkflow.template.id,
+                workflowVersionId: version.id,
+            };
+            const nextAssignment = activeAssignment
+                ? await replacePendingTaskWorkflow(taskId, assignmentInput, requestContext)
+                : await assignWorkflowToTask(taskId, assignmentInput, requestContext);
+            if (requestGeneration !== requestGenerationRef.current)
+                return;
+            setAssignment(nextAssignment);
+        }
+        catch (requestError) {
+            if (requestGeneration !== requestGenerationRef.current)
+                return;
+            setError(String(requestError?.message || 'Unable to assign workflow.'));
+        }
+        finally {
+            if (requestGeneration === requestGenerationRef.current)
+                setAssigning(false);
+        }
+    };
+    const handleCompleteStep = async () => {
+        if (!activeAssignment || !canCompleteCurrentStep)
+            return;
+        const currentStepStartedAt = [...(activeAssignment.events || [])]
+            .reverse()
+            .find((event) => event.eventType === 'step-started' && event.stepId === currentStep?.id)
+            ?.createdAt || activeAssignment.execution.startedAt || activeAssignment.execution.createdAt;
+        const evidenceComment = currentStep?.requiresCommentEvidence
+            ? [...comments]
+                .reverse()
+                .find((comment) => (comment.author === currentActorId
+                && comment.text.trim().length > 0
+                && Date.parse(comment.timestamp) >= Date.parse(currentStepStartedAt))) || null
+            : null;
+        if (currentStep?.requiresCommentEvidence && !evidenceComment) {
+            setError('Add a task comment for this workflow step before completing it.');
+            return;
+        }
+        const requestGeneration = requestGenerationRef.current;
+        setCompletingStep(true);
+        setError('');
+        try {
+            const commandId = typeof crypto !== 'undefined' && typeof crypto.randomUUID === 'function'
+                ? crypto.randomUUID()
+                : `${Date.now()}-${Math.random().toString(36).slice(2)}`;
+            const result = await completeCurrentWorkflowStep(activeAssignment.execution.id, commandId, requestContext, evidenceComment?.id, currentStep?.id);
+            if (requestGeneration !== requestGenerationRef.current)
+                return;
+            setAssignment((current) => current ? {
+                ...current,
+                execution: result.execution,
+                events: result.events,
+            } : current);
+        }
+        catch (requestError) {
+            if (requestGeneration !== requestGenerationRef.current)
+                return;
+            setError(String(requestError?.message || 'Unable to complete workflow step.'));
+        }
+        finally {
+            if (requestGeneration === requestGenerationRef.current)
+                setCompletingStep(false);
+        }
+    };
+    const handleRerunWorkflow = async () => {
+        const version = rerunWorkflow?.latestPublishedVersion;
+        if (!canRerunWorkflow || !rerunWorkflow || !version)
+            return;
+        const requestGeneration = requestGenerationRef.current;
+        setAssigning(true);
+        setError('');
+        try {
+            const nextAssignment = await assignWorkflowToTask(taskId, {
+                workflowTemplateId: rerunWorkflow.template.id,
+                workflowVersionId: version.id,
+            }, requestContext);
+            if (requestGeneration !== requestGenerationRef.current)
+                return;
+            setAssignment(nextAssignment);
+        }
+        catch (requestError) {
+            if (requestGeneration !== requestGenerationRef.current)
+                return;
+            setError(String(requestError?.message || 'Unable to run workflow again.'));
+        }
+        finally {
+            if (requestGeneration === requestGenerationRef.current)
+                setAssigning(false);
+        }
+    };
+    return (_jsxs("div", { className: `${styles.field} ${formStyles.compactMetaField} ${formStyles.workflowAssignmentField}`, children: [_jsxs("div", { className: formStyles.workflowAssignmentLabels, children: [_jsx("label", { id: "task-workflow-label", className: styles.label, children: "Workflow" }), _jsx("span", { id: "task-workflow-status-label", className: styles.label, children: "Status" })] }), _jsxs("div", { className: formStyles.workflowAssignmentControls, children: [_jsx(TaxonomyDropdown, { value: selectedValue, options: options, onChange: (value) => { void handleChange(value); }, placeholder: loading ? 'Loading workflows...' : 'None', ariaLabelledBy: "task-workflow-label", disabled: !canChange || (options.length === 1 && !activeAssignment), portalPanel: true, panelMinWidth: 280, panelAlign: "start", className: formStyles.workflowAssignmentSelector }), _jsxs("button", { type: "button", className: formStyles.workflowExecutionToggle, onClick: () => setExecutionExpanded((expanded) => !expanded), "aria-expanded": latestAssignment ? executionExpanded : undefined, "aria-controls": latestAssignment ? executionPanelId : undefined, "aria-label": executionStatusAccessibleLabel, disabled: !latestAssignment, children: [_jsxs("span", { children: [executionStatus, executionVersion ? (_jsxs("span", { className: formStyles.workflowExecutionVersion, children: [" \u00B7 ", executionVersion] })) : null] }), latestAssignment
+                                ? executionExpanded
+                                    ? _jsx(ChevronDown, { size: 13, "aria-hidden": "true" })
+                                    : _jsx(ChevronRight, { size: 13, "aria-hidden": "true" })
+                                : null] })] }), latestAssignment && executionExpanded ? (_jsxs("section", { id: executionPanelId, className: formStyles.workflowExecutionPanel, "aria-label": "Workflow execution", children: [_jsxs("div", { className: formStyles.workflowExecutionHeader, children: [_jsxs("div", { children: [_jsx("span", { className: formStyles.workflowExecutionEyebrow, children: "Workflow execution" }), _jsx("strong", { children: latestAssignment.version.name || latestAssignment.template.name })] }), executionCompleted && rerunWorkflow ? (_jsxs("button", { type: "button", className: "tf-button-secondary tf-button-compact", onClick: () => { void handleRerunWorkflow(); }, disabled: !canRerunWorkflow, children: [assigning
+                                        ? _jsx(LoaderCircle, { size: 14, className: formStyles.workflowExecutionSpinner, "aria-hidden": "true" })
+                                        : _jsx(RotateCcw, { size: 14, "aria-hidden": "true" }), "Run again"] })) : null] }), _jsxs("dl", { className: formStyles.workflowExecutionSummary, children: [_jsxs("div", { children: [_jsx("dt", { children: "Current step" }), _jsx("dd", { children: executionCompleted
+                                            ? 'Completed'
+                                            : currentStep?.name || (latestAssignment.execution.status === 'pending' ? 'Not started' : 'Not available') })] }), _jsxs("div", { children: [_jsx("dt", { children: "Owner" }), _jsx("dd", { children: !executionCompleted && currentStep ? ownerLabel(currentStep.ownerId) : 'Unassigned' })] }), _jsxs("div", { children: [_jsx("dt", { children: "Version" }), _jsx("dd", { children: latestAssignment.version.versionNumber ? `V${latestAssignment.version.versionNumber}` : 'Published' })] })] }), _jsx("ol", { className: `${formStyles.workflowExecutionSteps} tf-scrollbar`, children: orderedSteps.map((step, index) => {
+                            const isCompleted = completedStepIds.has(step.id);
+                            const isCurrent = !executionCompleted && step.id === latestAssignment.execution.currentStepId;
+                            const isSkipped = !isCompleted && !isCurrent && currentStepIndex >= 0 && index < currentStepIndex;
+                            const stepClassName = [
+                                isCompleted ? formStyles.workflowExecutionStepCompleted : '',
+                                isCurrent ? formStyles.workflowExecutionStepCurrent : '',
+                            ].filter(Boolean).join(' ') || undefined;
+                            return (_jsxs("li", { className: stepClassName, "aria-current": isCurrent ? 'step' : undefined, children: [_jsx("span", { className: formStyles.workflowExecutionStepMarker, "aria-hidden": "true", children: isCompleted
+                                            ? _jsx(CheckCircle, { size: 16 })
+                                            : isCurrent
+                                                ? _jsx(PlayCircle, { size: 17 })
+                                                : _jsx(Circle, { size: 15 }) }), _jsxs("span", { className: formStyles.workflowExecutionStepBody, children: [_jsxs("span", { className: formStyles.workflowExecutionStepTitle, children: [_jsx("span", { children: index + 1 }), _jsx("strong", { children: step.name })] }), _jsxs("span", { className: formStyles.workflowExecutionStepMeta, children: [ownerLabel(step.ownerId), " \u00B7 ", step.isRequired ? 'Required' : 'Optional'] })] }), _jsx("span", { className: formStyles.workflowExecutionStepState, children: isCompleted ? 'Completed' : isSkipped ? 'Skipped' : isCurrent && (canCompleteCurrentStep || completingStep) ? (_jsxs("button", { type: "button", className: "tf-button-secondary tf-button-compact", onClick: () => { void handleCompleteStep(); }, disabled: completingStep, children: [completingStep
+                                                    ? _jsx(LoaderCircle, { size: 14, className: formStyles.workflowExecutionSpinner, "aria-hidden": "true" })
+                                                    : _jsx(Check, { size: 14, "aria-hidden": "true" }), "Complete Step"] })) : isCurrent ? 'Current' : step.id === pendingStartStepId ? 'Starts here' : 'Upcoming' })] }, step.id));
+                        }) }), orderedSteps.length === 0 ? (_jsx("p", { className: formStyles.workflowExecutionEmpty, children: "No steps are available for this workflow version." })) : null] })) : null, error ? (_jsxs("span", { className: formStyles.workflowAssignmentError, role: "alert", children: [error, isPending && taskStatus === 'in-progress' && onActivatePendingWorkflow ? (_jsx("button", { type: "button", className: "tf-button-secondary tf-button-compact", onClick: () => setActivationRetryToken((value) => value + 1), disabled: assigning, children: "Retry" })) : null] })) : null] }));
+}

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

@@ -0,0 +1,8 @@
+import type { WorkstreamItem } from '../../types';
+interface TaskWorkstreamPickerProps {
+    workstreams: WorkstreamItem[];
+    onSelect: (workstream: WorkstreamItem) => void | Promise<void>;
+    disabled?: boolean;
+}
+export declare function TaskWorkstreamPicker({ workstreams, onSelect, disabled, }: TaskWorkstreamPickerProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/task/TaskWorkstreamPicker.js

@@ -0,0 +1,24 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import React from 'react';
+import { Link2 } from 'lucide-react';
+import { getWorkstreamReferenceLabel } from '../../utils/planningReferences';
+import { TaxonomyDropdown } from '../ui/TaxonomyDropdown';
+import styles from '../../Taskforce.module.css';
+export function TaskWorkstreamPicker({ workstreams, onSelect, disabled = false, }) {
+    const availableWorkstreams = React.useMemo(() => workstreams.filter((workstream) => !workstream.isArchived), [workstreams]);
+    const workstreamById = React.useMemo(() => new Map(availableWorkstreams.map((workstream) => [workstream.id, workstream])), [availableWorkstreams]);
+    const options = React.useMemo(() => availableWorkstreams.map((workstream) => ({
+        value: workstream.id,
+        label: `${getWorkstreamReferenceLabel(workstream) || workstream.id} — ${workstream.title}`,
+    })), [availableWorkstreams]);
+    return (_jsx(TaxonomyDropdown, { value: "", options: options, onChange: (value) => {
+            const workstream = workstreamById.get(String(value));
+            if (workstream)
+                void onSelect(workstream);
+        }, placeholder: "Select workstream\u2026", ariaLabel: "Link task to workstream", title: options.length > 0 ? 'Link to workstream' : 'No workstreams available', disabled: disabled || options.length === 0, className: styles.taskWorkstreamPicker, panelClassName: styles.taskWorkstreamPickerPanel, portalPanel: true, panelAlign: "start", panelMinWidth: 280, searchable: true, searchPlaceholder: "Search workstreams\u2026", noResultsText: "No matching workstreams.", hideChevron: true, triggerContent: (_jsx("span", { className: styles.taskWorkstreamPickerIcon, children: _jsx(Link2, { size: 13, "aria-hidden": "true" }) })), renderOptionContent: (option) => {
+            const workstream = workstreamById.get(String(option.value));
+            if (!workstream)
+                return option.label;
+            return (_jsxs("span", { className: styles.taskWorkstreamPickerOption, children: [_jsx("span", { children: getWorkstreamReferenceLabel(workstream) || workstream.id }), _jsx("span", { children: workstream.title })] }));
+        } }));
+}

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

@@ -0,0 +1,18 @@
+import type { DeletedTaskRecord } from '../../types';
+import type { DeletedTaskRestoreBatchResult } from '../../hooks/useTaskMutations';
+import type { TaskRestoreDestination } from '../../shared/taskRestoreDestination';
+import type { TaskforceTheme } from '../../utils/theme';
+interface TrashRestoreControlsProps {
+    theme: TaskforceTheme;
+    selectedRecords: DeletedTaskRecord[];
+    matchingCount: number;
+    allMatchingSelected: boolean;
+    someMatchingSelected: boolean;
+    fullTrashCount: number;
+    onSelectAllMatching: () => void;
+    onClearSelection: () => void;
+    onRestore: (records: DeletedTaskRecord[], restoreDestination: TaskRestoreDestination, onProgress?: (result: DeletedTaskRestoreBatchResult) => void) => Promise<DeletedTaskRestoreBatchResult>;
+    onEmptyEntireTrash?: () => void;
+}
+export declare function TrashRestoreControls({ theme, selectedRecords, matchingCount, allMatchingSelected, someMatchingSelected, fullTrashCount, onSelectAllMatching, onClearSelection, onRestore, onEmptyEntireTrash, }: TrashRestoreControlsProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/task/TrashRestoreControls.js

@@ -0,0 +1,71 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { useEffect, useMemo, useRef, useState } from 'react';
+import { Archive, Loader2, RotateCcw, Trash2, X } from 'lucide-react';
+import { Modal } from '../ui/Modal';
+import styles from './TrashRestoreControls.module.css';
+export function TrashRestoreControls({ theme, selectedRecords, matchingCount, allMatchingSelected, someMatchingSelected, fullTrashCount, onSelectAllMatching, onClearSelection, onRestore, onEmptyEntireTrash, }) {
+    const masterCheckboxRef = useRef(null);
+    const [confirmOpen, setConfirmOpen] = useState(false);
+    const [restoreDestination, setRestoreDestination] = useState('previous');
+    const [running, setRunning] = useState(false);
+    const [progress, setProgress] = useState(null);
+    const archivedCount = useMemo(() => selectedRecords.filter((record) => record.taskSnapshot.isArchived === true).length, [selectedRecords]);
+    const activeCount = selectedRecords.length - archivedCount;
+    useEffect(() => {
+        if (masterCheckboxRef.current) {
+            masterCheckboxRef.current.indeterminate = someMatchingSelected;
+        }
+    }, [someMatchingSelected]);
+    const startRestore = async () => {
+        if (selectedRecords.length === 0 || running)
+            return;
+        setRunning(true);
+        setProgress({
+            requested: selectedRecords.length,
+            completed: 0,
+            succeeded: [],
+            failed: [],
+        });
+        const result = await onRestore(selectedRecords, restoreDestination, setProgress);
+        setProgress(result);
+        setRunning(false);
+        if (result.failed.length === 0) {
+            setConfirmOpen(false);
+            setProgress(null);
+        }
+    };
+    const openConfirmation = (destination) => {
+        setRestoreDestination(destination);
+        setProgress(null);
+        setConfirmOpen(true);
+    };
+    const forceArchive = restoreDestination === 'archive';
+    const destinationArchivedCount = forceArchive ? selectedRecords.length : archivedCount;
+    const destinationActiveCount = forceArchive ? 0 : activeCount;
+    return (_jsxs(_Fragment, { children: [_jsxs("div", { className: styles.toolbar, "aria-label": "Trash restore selection", children: [_jsxs("label", { className: styles.masterSelection, children: [_jsx("input", { ref: masterCheckboxRef, type: "checkbox", checked: allMatchingSelected, disabled: matchingCount === 0 || running, onChange: (event) => {
+                                    if (event.target.checked)
+                                        onSelectAllMatching();
+                                    else
+                                        onClearSelection();
+                                }, "aria-label": "Select all matching deleted tasks" }), _jsxs("span", { className: styles.selectedCount, children: [selectedRecords.length, " selected"] })] }), _jsx("button", { type: "button", className: "tf-control-icon", onClick: onClearSelection, disabled: selectedRecords.length === 0 || running, "aria-label": "Clear selected tasks", title: "Clear selection", children: _jsx(X, { size: 15, "aria-hidden": "true" }) }), _jsxs("button", { type: "button", className: `tf-control-icon ${styles.actionButton}`, onClick: () => openConfirmation('previous'), disabled: selectedRecords.length === 0 || running, children: [_jsx(RotateCcw, { size: 15, "aria-hidden": "true" }), "Restore"] }), _jsxs("button", { type: "button", className: `tf-control-icon ${styles.actionButton}`, onClick: () => openConfirmation('archive'), disabled: selectedRecords.length === 0 || running, title: "Restore selected tasks directly to Archive", children: [_jsx(Archive, { size: 15, "aria-hidden": "true" }), "Restore to archive"] }), onEmptyEntireTrash && (_jsxs("button", { type: "button", className: `tf-control-icon ${styles.actionButton} ${styles.emptyButton}`, onClick: onEmptyEntireTrash, disabled: fullTrashCount === 0 || running, title: fullTrashCount > 0
+                            ? `Permanently delete all ${fullTrashCount} tasks in Trash; filters and selection do not limit this action.`
+                            : 'Trash is already empty', children: [_jsx(Trash2, { size: 14, "aria-hidden": "true" }), "Empty Trash"] }))] }), _jsx(Modal, { isOpen: confirmOpen, onClose: () => {
+                    if (!running) {
+                        setConfirmOpen(false);
+                        setProgress(null);
+                    }
+                }, closeDisabled: running, closeOnOverlayClick: !running, size: "sm", theme: theme, title: forceArchive ? 'Restore selected tasks to Archive?' : 'Restore selected tasks?', footer: (_jsxs(_Fragment, { children: [_jsx("button", { type: "button", className: "tf-button-secondary tf-button-compact", onClick: () => {
+                                setConfirmOpen(false);
+                                setProgress(null);
+                            }, disabled: running, children: "Cancel" }), _jsxs("button", { type: "button", className: "tf-button-primary tf-button-compact", "data-modal-initial-focus": true, onClick: () => void startRestore(), disabled: running || selectedRecords.length === 0, children: [running
+                                    ? _jsx(Loader2, { size: 15, className: styles.spinner })
+                                    : forceArchive
+                                        ? _jsx(Archive, { size: 15 })
+                                        : _jsx(RotateCcw, { size: 15 }), progress?.failed.length
+                                    ? 'Retry failed'
+                                    : forceArchive
+                                        ? 'Restore to archive'
+                                        : 'Restore'] })] })), children: _jsxs("div", { className: styles.dialogBody, children: [_jsxs("p", { children: ["Restore ", selectedRecords.length, " task", selectedRecords.length === 1 ? '' : 's', "?"] }), _jsxs("p", { className: styles.destinationSummary, children: [destinationArchivedCount, " to Archived \u00B7 ", destinationActiveCount, " to Active"] }), _jsx("p", { className: styles.hint, children: forceArchive
+                                ? 'Active tasks will be marked Done and restored directly to Archive. Cancelled tasks remain Cancelled.'
+                                : 'Each task returns to the lifecycle state it had before deletion.' }), progress && (_jsxs("div", { className: styles.progress, "aria-live": "polite", children: [_jsxs("strong", { children: [progress.completed, " / ", progress.requested, " completed"] }), progress.failed.length > 0 && (_jsxs("div", { className: styles.failures, children: [_jsxs("p", { children: [progress.failed.length, " failed and remain selected:"] }), _jsx("ul", { children: progress.failed.slice(0, 8).map((failure) => (_jsxs("li", { children: [_jsx("span", { children: failure.title || failure.taskId }), _jsx("span", { children: failure.message })] }, failure.deletedRecordId))) }), progress.failed.length > 8 && (_jsxs("p", { children: ["And ", progress.failed.length - 8, " more."] }))] }))] }))] }) })] }));
+}

package/dist/components/ui/AiIdentityRosterCard.d.ts

@@ -0,0 +1,20 @@
+import { type CSSProperties, type ReactNode } from 'react';
+type AiIdentityRosterCardProps = {
+    name: string;
+    username?: string | null;
+    subtitle: string;
+    avatar: ReactNode;
+    selected: boolean;
+    disabled?: boolean;
+    onSelect: () => void;
+    ariaLabel?: string;
+    avatarVariant?: 'portrait' | 'logo';
+    avatarClassName?: string;
+    avatarStyle?: CSSProperties;
+    className?: string;
+    topUtility?: ReactNode;
+    bottomUtility?: ReactNode;
+    footer?: ReactNode;
+};
+export declare function AiIdentityRosterCard({ name, username, subtitle, avatar, selected, disabled, onSelect, ariaLabel, avatarVariant, avatarClassName, avatarStyle, className, topUtility, bottomUtility, footer, }: AiIdentityRosterCardProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/ui/AiIdentityRosterCard.js

@@ -0,0 +1,5 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import styles from '../../Taskforce.module.css';
+export function AiIdentityRosterCard({ name, username, subtitle, avatar, selected, disabled = false, onSelect, ariaLabel, avatarVariant = 'portrait', avatarClassName = '', avatarStyle, className = '', topUtility, bottomUtility, footer, }) {
+    return (_jsxs("button", { type: "button", className: `${styles.aiProfileGroup} ${selected ? styles.aiProfileGroupSelected : ''} ${className}`.trim(), onClick: onSelect, disabled: disabled, "aria-label": ariaLabel, "aria-pressed": selected, children: [topUtility, bottomUtility, _jsxs("span", { className: styles.aiProfileGroupHeader, children: [_jsx("span", { className: `${styles.aiProfileGroupAvatar} ${avatarVariant === 'logo' ? styles.aiProfileGroupAvatarLogo : ''} ${avatarClassName}`.trim(), style: avatarStyle, "aria-hidden": "true", children: avatar }), _jsxs("span", { className: styles.aiProfileGroupIdentity, children: [_jsx("span", { className: styles.aiProfileName, children: name }), username ? _jsxs("span", { className: styles.aiProfileHandle, children: ["@", username] }) : null, _jsx("span", { className: styles.aiProfileRole, children: subtitle }), footer] })] })] }));
+}

package/dist/components/ui/AssetTraySortControl.d.ts

@@ -0,0 +1,10 @@
+import type { TraySortField, TraySortOrder } from '../../utils/assetTraySorting';
+interface AssetTraySortControlProps {
+    field: TraySortField;
+    order: TraySortOrder;
+    onFieldChange: (field: TraySortField) => void;
+    onOrderChange: (order: TraySortOrder) => void;
+    className?: string;
+}
+export declare function AssetTraySortControl({ field, order, onFieldChange, onOrderChange, className, }: AssetTraySortControlProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/ui/AssetTraySortControl.js

@@ -0,0 +1,38 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import React from 'react';
+import { ArrowDown, ArrowUp, ArrowUpDown, Check, ChevronDown } from 'lucide-react';
+import { TRAY_SORT_OPTIONS } from '../../utils/assetTraySorting';
+import styles from './AssetTraySortControl.module.css';
+export function AssetTraySortControl({ field, order, onFieldChange, onOrderChange, className, }) {
+    const [isOpen, setIsOpen] = React.useState(false);
+    const rootRef = React.useRef(null);
+    const selectedOption = TRAY_SORT_OPTIONS.find((option) => option.value === field) ?? TRAY_SORT_OPTIONS[0];
+    const DirectionIcon = order === 'desc' ? ArrowDown : ArrowUp;
+    React.useEffect(() => {
+        if (!isOpen)
+            return;
+        const handlePointerDown = (event) => {
+            if (rootRef.current?.contains(event.target))
+                return;
+            setIsOpen(false);
+        };
+        const handleKeyDown = (event) => {
+            if (event.key === 'Escape')
+                setIsOpen(false);
+        };
+        document.addEventListener('mousedown', handlePointerDown);
+        document.addEventListener('keydown', handleKeyDown);
+        return () => {
+            document.removeEventListener('mousedown', handlePointerDown);
+            document.removeEventListener('keydown', handleKeyDown);
+        };
+    }, [isOpen]);
+    const handleFieldSelect = (nextField) => {
+        onFieldChange(nextField);
+        setIsOpen(false);
+    };
+    return (_jsxs("div", { ref: rootRef, className: `${styles.root} ${className || ''}`.trim(), children: [_jsxs("button", { type: "button", className: `${styles.trigger} ${isOpen ? styles.triggerOpen : ''}`.trim(), onClick: () => setIsOpen((open) => !open), "aria-haspopup": "menu", "aria-expanded": isOpen, "aria-label": `Sort tray by ${selectedOption.label}`, title: `Sort by ${selectedOption.label}`, children: [_jsx(ArrowUpDown, { size: 13 }), _jsx("span", { className: styles.triggerLabel, children: selectedOption.label }), _jsx(ChevronDown, { size: 13 })] }), _jsx("button", { type: "button", className: styles.directionToggle, onClick: () => onOrderChange(order === 'desc' ? 'asc' : 'desc'), "aria-label": `Sort tray ${order === 'desc' ? 'descending' : 'ascending'}`, title: order === 'desc' ? 'Sort descending' : 'Sort ascending', children: _jsx(DirectionIcon, { size: 13 }) }), isOpen ? (_jsxs("div", { className: styles.menu, role: "menu", "aria-label": "Sort tray items", children: [_jsx("div", { className: styles.menuLabel, children: "Sort by" }), TRAY_SORT_OPTIONS.map((option) => {
+                        const isSelected = option.value === field;
+                        return (_jsxs("button", { type: "button", role: "menuitemradio", "aria-checked": isSelected, className: `${styles.menuItem} ${isSelected ? styles.menuItemActive : ''}`.trim(), onClick: () => handleFieldSelect(option.value), children: [_jsx("span", { className: styles.menuItemLabel, children: option.label }), isSelected ? _jsx(Check, { size: 13 }) : null] }, option.value));
+                    })] })) : null] }));
+}

package/dist/components/ui/AssigneeIdentity.d.ts

@@ -0,0 +1,12 @@
+import { type LucideIcon } from 'lucide-react';
+import { type TaskAssigneeOption } from '../../utils/assignees';
+export declare function AssigneeAvatar({ option, size, variant, unassignedIcon, }: {
+    option: TaskAssigneeOption;
+    size?: number;
+    variant?: 'default' | 'card';
+    unassignedIcon?: LucideIcon;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function AssigneeIdentity({ option, size, }: {
+    option: TaskAssigneeOption;
+    size?: number;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/components/ui/AssigneeIdentity.js

@@ -0,0 +1,41 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import * as Icons from 'lucide-react';
+import { HelpCircle } from 'lucide-react';
+import { getAiProfileDefaultLogoUrl } from '../../utils/aiProfileDefaultLogo';
+import { buildVersionedAvatarUrl } from '../../utils/avatarDisplay';
+import { resolveColor } from '../../utils/constants';
+import { isUnassignedAssignee, TASK_ASSIGNEE_UNASSIGNED_ICON, } from '../../utils/assignees';
+import { useFallbackImageUrl } from './useFallbackImageUrl';
+import styles from './AssigneeIdentity.module.css';
+export function AssigneeAvatar({ option, size = 22, variant = 'default', unassignedIcon, }) {
+    const unassigned = isUnassignedAssignee(option.value);
+    const customAvatarUrl = unassigned ? '' : buildVersionedAvatarUrl(option.avatarUrl, option.avatarRevision, option.avatarUpdatedAt);
+    const defaultLogoUrl = !unassigned && option.kind === 'agent'
+        ? getAiProfileDefaultLogoUrl({
+            name: option.label,
+            username: option.username,
+            surfaceType: option.surfaceType,
+            providerMetadata: option.providerMetadata,
+        })
+        : '';
+    const { activeImageUrl, handleImageError } = useFallbackImageUrl(customAvatarUrl, defaultLogoUrl);
+    const iconByName = Icons;
+    const iconName = unassigned ? TASK_ASSIGNEE_UNASSIGNED_ICON : option.icon;
+    const Icon = unassigned && unassignedIcon
+        ? unassignedIcon
+        : (iconName && iconByName[iconName] ? iconByName[iconName] : HelpCircle);
+    const iconSize = unassigned
+        ? Math.max(13, Math.round(size * 0.56))
+        : Math.max(14, size - 6);
+    const accentColor = resolveColor(option.color)
+        || (option.kind === 'member' ? 'var(--color-green-500, #22c55e)' : 'var(--text-secondary, #888)');
+    return (_jsx("span", { className: `${styles.avatar} ${defaultLogoUrl ? styles.provider : styles.person} ${unassigned ? styles.unassigned : ''} ${variant === 'card' ? styles.card : ''}`.trim(), style: {
+            width: size,
+            height: size,
+            color: activeImageUrl ? undefined : accentColor,
+            '--assignee-avatar-color': accentColor,
+        }, "data-assignee-avatar": variant, "aria-hidden": "true", children: activeImageUrl ? (_jsx("img", { src: activeImageUrl, alt: "", onError: handleImageError })) : (_jsx(Icon, { size: iconSize, strokeWidth: unassigned ? 1.6 : undefined })) }));
+}
+export function AssigneeIdentity({ option, size = 22, }) {
+    return (_jsxs("span", { className: styles.identity, children: [_jsx(AssigneeAvatar, { option: option, size: size }), _jsx("span", { className: styles.label, children: option.label })] }));
+}