@taskforcehq/taskforce 0.3.326 → 0.3.328

package/dist/components/features/workflowManager/useWorkflowManager.js

@@ -0,0 +1,213 @@
+import { useCallback, useEffect, useRef, useState } from 'react';
+import { createWorkflowDraft, createWorkflowTemplate, getWorkflowTemplate, listWorkflowTemplates, publishWorkflowDraft, saveWorkflowDraft, } from './workflowManagerApi.js';
+export function useWorkflowManager(workspaceId) {
+    const [workflows, setWorkflows] = useState([]);
+    const [selectedWorkflowId, setSelectedWorkflowId] = useState('');
+    const [selectedWorkflow, setSelectedWorkflow] = useState(null);
+    const [loadingLibrary, setLoadingLibrary] = useState(true);
+    const [loadingDetails, setLoadingDetails] = useState(false);
+    const [creatingWorkflow, setCreatingWorkflow] = useState(false);
+    const [savingWorkflow, setSavingWorkflow] = useState(false);
+    const [publishingWorkflow, setPublishingWorkflow] = useState(false);
+    const [creatingDraft, setCreatingDraft] = useState(false);
+    const [detailReloadKey, setDetailReloadKey] = useState(0);
+    const [error, setError] = useState(null);
+    const libraryRequestId = useRef(0);
+    const activeWorkspaceId = useRef(workspaceId);
+    activeWorkspaceId.current = workspaceId;
+    const refreshLibrary = useCallback(async () => {
+        const requestId = ++libraryRequestId.current;
+        setLoadingLibrary(true);
+        setError(null);
+        try {
+            const nextWorkflows = await listWorkflowTemplates();
+            if (requestId !== libraryRequestId.current)
+                return;
+            setWorkflows(nextWorkflows);
+            setSelectedWorkflowId((current) => (current && nextWorkflows.some(({ template }) => template.id === current)
+                ? current
+                : nextWorkflows[0]?.template.id || ''));
+        }
+        catch (nextError) {
+            if (requestId !== libraryRequestId.current)
+                return;
+            setError(String(nextError?.message || nextError || 'Unable to load workflows.'));
+        }
+        finally {
+            if (requestId === libraryRequestId.current)
+                setLoadingLibrary(false);
+        }
+    }, [workspaceId]);
+    useEffect(() => {
+        setWorkflows([]);
+        setSelectedWorkflowId('');
+        setSelectedWorkflow(null);
+        void refreshLibrary();
+    }, [refreshLibrary, workspaceId]);
+    useEffect(() => {
+        let cancelled = false;
+        if (!selectedWorkflowId) {
+            setSelectedWorkflow(null);
+            setLoadingDetails(false);
+            return;
+        }
+        setLoadingDetails(true);
+        setError(null);
+        void getWorkflowTemplate(selectedWorkflowId)
+            .then((workflow) => {
+            if (!cancelled)
+                setSelectedWorkflow(workflow);
+        })
+            .catch((nextError) => {
+            if (!cancelled) {
+                setSelectedWorkflow(null);
+                setError(String(nextError?.message || nextError || 'Unable to load workflow.'));
+            }
+        })
+            .finally(() => {
+            if (!cancelled)
+                setLoadingDetails(false);
+        });
+        return () => {
+            cancelled = true;
+        };
+    }, [detailReloadKey, selectedWorkflowId]);
+    const retry = useCallback(() => {
+        if (selectedWorkflowId && !selectedWorkflow) {
+            setDetailReloadKey((current) => current + 1);
+            return;
+        }
+        void refreshLibrary();
+    }, [refreshLibrary, selectedWorkflow, selectedWorkflowId]);
+    const createWorkflow = useCallback(async (input) => {
+        const requestWorkspaceId = workspaceId;
+        setCreatingWorkflow(true);
+        setError(null);
+        try {
+            const workflow = await createWorkflowTemplate(input);
+            if (activeWorkspaceId.current !== requestWorkspaceId)
+                return true;
+            setSelectedWorkflow(workflow);
+            setSelectedWorkflowId(workflow.template.id);
+            await refreshLibrary();
+            if (activeWorkspaceId.current === requestWorkspaceId) {
+                setSelectedWorkflowId(workflow.template.id);
+            }
+            return true;
+        }
+        catch (nextError) {
+            if (activeWorkspaceId.current !== requestWorkspaceId)
+                return false;
+            setError(String(nextError?.message || nextError || 'Unable to create workflow.'));
+            return false;
+        }
+        finally {
+            setCreatingWorkflow(false);
+        }
+    }, [refreshLibrary, workspaceId]);
+    const saveDraft = useCallback(async (input) => {
+        if (!selectedWorkflowId)
+            return false;
+        const requestWorkspaceId = workspaceId;
+        const requestWorkflowId = selectedWorkflowId;
+        setSavingWorkflow(true);
+        setError(null);
+        try {
+            const workflow = await saveWorkflowDraft(requestWorkflowId, {
+                name: input.name,
+                description: input.description,
+                steps: input.steps,
+            });
+            if (activeWorkspaceId.current !== requestWorkspaceId)
+                return true;
+            setSelectedWorkflow(workflow);
+            await refreshLibrary();
+            if (activeWorkspaceId.current === requestWorkspaceId)
+                setSelectedWorkflowId(requestWorkflowId);
+            return true;
+        }
+        catch (nextError) {
+            if (activeWorkspaceId.current !== requestWorkspaceId)
+                return false;
+            setError(String(nextError?.message || nextError || 'Unable to save workflow draft.'));
+            return false;
+        }
+        finally {
+            setSavingWorkflow(false);
+        }
+    }, [refreshLibrary, selectedWorkflowId, workspaceId]);
+    const publishDraft = useCallback(async () => {
+        if (!selectedWorkflowId)
+            return false;
+        const requestWorkspaceId = workspaceId;
+        const requestWorkflowId = selectedWorkflowId;
+        setPublishingWorkflow(true);
+        setError(null);
+        try {
+            const workflow = await publishWorkflowDraft(requestWorkflowId);
+            if (activeWorkspaceId.current !== requestWorkspaceId)
+                return true;
+            setSelectedWorkflow(workflow);
+            await refreshLibrary();
+            if (activeWorkspaceId.current === requestWorkspaceId)
+                setSelectedWorkflowId(requestWorkflowId);
+            return true;
+        }
+        catch (nextError) {
+            if (activeWorkspaceId.current !== requestWorkspaceId)
+                return false;
+            setError(String(nextError?.message || nextError || 'Unable to publish workflow.'));
+            return false;
+        }
+        finally {
+            setPublishingWorkflow(false);
+        }
+    }, [refreshLibrary, selectedWorkflowId, workspaceId]);
+    const createNextDraft = useCallback(async () => {
+        if (!selectedWorkflowId)
+            return false;
+        const requestWorkspaceId = workspaceId;
+        const requestWorkflowId = selectedWorkflowId;
+        setCreatingDraft(true);
+        setError(null);
+        try {
+            const workflow = await createWorkflowDraft(requestWorkflowId);
+            if (activeWorkspaceId.current !== requestWorkspaceId)
+                return true;
+            setSelectedWorkflow(workflow);
+            await refreshLibrary();
+            if (activeWorkspaceId.current === requestWorkspaceId)
+                setSelectedWorkflowId(requestWorkflowId);
+            return true;
+        }
+        catch (nextError) {
+            if (activeWorkspaceId.current !== requestWorkspaceId)
+                return false;
+            setError(String(nextError?.message || nextError || 'Unable to create workflow draft.'));
+            return false;
+        }
+        finally {
+            setCreatingDraft(false);
+        }
+    }, [refreshLibrary, selectedWorkflowId, workspaceId]);
+    return {
+        workflows,
+        selectedWorkflowId,
+        selectedWorkflow,
+        loadingLibrary,
+        loadingDetails,
+        creatingWorkflow,
+        savingWorkflow,
+        publishingWorkflow,
+        creatingDraft,
+        error,
+        setSelectedWorkflowId,
+        refreshLibrary,
+        retry,
+        createWorkflow,
+        saveDraft,
+        publishDraft,
+        createNextDraft,
+        clearError: () => setError(null),
+    };
+}

package/dist/components/features/workflowManager/workflowManagerApi.d.ts

@@ -0,0 +1,52 @@
+import type { WorkflowAssignmentDetails, WorkflowStepRecord, WorkflowTemplateDetails, WorkflowTemplateSummary } from './types.js';
+import type { TaskItem } from '../../../types.js';
+export declare class WorkflowManagerApiError extends Error {
+    readonly code?: string | undefined;
+    constructor(message: string, code?: string | undefined);
+}
+export type WorkflowApiRequestContext = {
+    apiBaseUrl?: string;
+    workspaceId?: string | null;
+    runtimeMode?: 'local' | 'cloud';
+};
+export declare function listWorkflowTemplates(context?: WorkflowApiRequestContext): Promise<WorkflowTemplateSummary[]>;
+export declare function getTaskWorkflowAssignment(taskId: string, context?: WorkflowApiRequestContext): Promise<WorkflowAssignmentDetails | null>;
+export type WorkflowCompletionProjection = {
+    executionId: string;
+    taskId: string;
+    assignmentSnapshot: unknown;
+    taskSnapshot?: TaskItem | null;
+    taskAuthoritative?: unknown;
+};
+export declare function applyCloudWorkflowCompletionProjection(projection: WorkflowCompletionProjection, context?: WorkflowApiRequestContext): Promise<TaskItem | null>;
+export declare function completeCurrentWorkflowStep(executionId: string, idempotencyKey: string, context?: WorkflowApiRequestContext, evidenceCommentId?: string, expectedStepId?: string): Promise<{
+    execution: WorkflowAssignmentDetails['execution'];
+    events: NonNullable<WorkflowAssignmentDetails['events']>;
+    nextStep: WorkflowStepRecord | null;
+    taskAssignee: string | null;
+    taskSnapshot?: TaskItem | null;
+}>;
+export declare function assignWorkflowToTask(taskId: string, input: {
+    workflowTemplateId: string;
+    workflowVersionId: string;
+}, context?: WorkflowApiRequestContext): Promise<WorkflowAssignmentDetails>;
+export declare function replacePendingTaskWorkflow(taskId: string, input: {
+    workflowTemplateId: string;
+    workflowVersionId: string;
+}, context?: WorkflowApiRequestContext): Promise<WorkflowAssignmentDetails>;
+export declare function removePendingTaskWorkflow(taskId: string, context?: WorkflowApiRequestContext): Promise<void>;
+export declare function getWorkflowTemplate(workflowId: string): Promise<WorkflowTemplateDetails>;
+export declare function createWorkflowTemplate(input: {
+    name: string;
+    description?: string;
+    steps?: WorkflowDraftStepInput[];
+}): Promise<WorkflowTemplateDetails>;
+export declare function saveWorkflowDraft(workflowId: string, input: {
+    name: string;
+    description?: string;
+    steps: WorkflowDraftStepInput[];
+}): Promise<WorkflowTemplateDetails>;
+export declare function publishWorkflowDraft(workflowId: string): Promise<WorkflowTemplateDetails>;
+export declare function createWorkflowDraft(workflowId: string): Promise<WorkflowTemplateDetails>;
+export type WorkflowDraftStepInput = Omit<WorkflowStepRecord, 'id' | 'workflowVersionId' | 'position'>;
+export declare function replaceWorkflowDraftSteps(workflowId: string, steps: WorkflowDraftStepInput[]): Promise<WorkflowTemplateDetails>;

package/dist/components/features/workflowManager/workflowManagerApi.js

@@ -0,0 +1,142 @@
+import { fetchTaskforceApi } from '../../../utils/taskforceApiClient.js';
+import { dispatchTaskforceTasksMutated } from '../../../utils/taskEvents.js';
+export class WorkflowManagerApiError extends Error {
+    code;
+    constructor(message, code) {
+        super(message);
+        this.code = code;
+        this.name = 'WorkflowManagerApiError';
+    }
+}
+async function requestJson(path, init, context) {
+    const headers = new Headers(init?.headers || undefined);
+    if (init?.body)
+        headers.set('Content-Type', 'application/json');
+    const workspaceId = String(context?.workspaceId || '').trim();
+    if (workspaceId && workspaceId !== 'default')
+        headers.set('x-taskforce-workspace-id', workspaceId);
+    const response = await fetchTaskforceApi(path, {
+        credentials: 'include',
+        ...init,
+        headers,
+    }, context?.apiBaseUrl);
+    const payload = await response.json().catch(() => ({}));
+    if (!response.ok || payload.success === false) {
+        throw new WorkflowManagerApiError(String(payload.error || `Workflow request failed (${response.status}).`), payload.code);
+    }
+    return payload;
+}
+export async function listWorkflowTemplates(context) {
+    const payload = await requestJson('/api/taskforce/workflows', undefined, context);
+    return Array.isArray(payload.workflows) ? payload.workflows : [];
+}
+export async function getTaskWorkflowAssignment(taskId, context) {
+    const payload = await requestJson(`/api/taskforce/tasks/${encodeURIComponent(taskId)}/workflow`, undefined, context);
+    return payload.assignment || null;
+}
+export async function applyCloudWorkflowCompletionProjection(projection, context) {
+    if (context?.runtimeMode !== 'local' || !projection.assignmentSnapshot) {
+        return projection.taskSnapshot || null;
+    }
+    try {
+        const payload = await requestJson(`/api/taskforce/workflow-executions/${encodeURIComponent(projection.executionId)}/apply-cloud-state`, {
+            method: 'POST',
+            body: JSON.stringify({
+                assignment: projection.assignmentSnapshot,
+                taskAuthoritative: projection.taskAuthoritative,
+            }),
+        }, { workspaceId: context?.workspaceId });
+        return payload.task || null;
+    }
+    catch {
+        // The cloud command is authoritative; normal sync can repair a failed local projection update.
+        return null;
+    }
+}
+export async function completeCurrentWorkflowStep(executionId, idempotencyKey, context, evidenceCommentId, expectedStepId) {
+    const payload = await requestJson(`/api/taskforce/workflow-executions/${encodeURIComponent(executionId)}/complete-step?taskforceCloud=1`, {
+        method: 'POST',
+        body: JSON.stringify({
+            idempotencyKey,
+            ...(evidenceCommentId ? { evidenceCommentId } : {}),
+            ...(expectedStepId ? { expectedStepId } : {}),
+        }),
+    }, context);
+    if (!payload.result)
+        throw new WorkflowManagerApiError('The workflow step result was not returned.');
+    let installedTask = payload.result.taskSnapshot || null;
+    if (payload.result.assignmentSnapshot && payload.result.route !== 'local-outbox') {
+        installedTask = await applyCloudWorkflowCompletionProjection({
+            executionId,
+            taskId: payload.result.execution.taskId,
+            assignmentSnapshot: payload.result.assignmentSnapshot,
+            taskSnapshot: payload.result.taskSnapshot,
+            taskAuthoritative: payload.result.taskAuthoritative,
+        }, context);
+    }
+    if (payload.result.taskSnapshot) {
+        dispatchTaskforceTasksMutated({
+            workspaceId: context?.workspaceId,
+            taskId: payload.result.taskSnapshot.id,
+            reason: 'workflow-step',
+            ...(installedTask ? { authoritativeTask: installedTask } : {}),
+        });
+    }
+    return payload.result;
+}
+export async function assignWorkflowToTask(taskId, input, context) {
+    const payload = await requestJson(`/api/taskforce/tasks/${encodeURIComponent(taskId)}/workflow`, { method: 'POST', body: JSON.stringify(input) }, context);
+    if (!payload.assignment)
+        throw new WorkflowManagerApiError('The workflow assignment was not returned.');
+    return payload.assignment;
+}
+export async function replacePendingTaskWorkflow(taskId, input, context) {
+    const payload = await requestJson(`/api/taskforce/tasks/${encodeURIComponent(taskId)}/workflow`, { method: 'PUT', body: JSON.stringify(input) }, context);
+    if (!payload.assignment)
+        throw new WorkflowManagerApiError('The workflow assignment was not returned.');
+    return payload.assignment;
+}
+export async function removePendingTaskWorkflow(taskId, context) {
+    await requestJson(`/api/taskforce/tasks/${encodeURIComponent(taskId)}/workflow`, { method: 'DELETE' }, context);
+}
+export async function getWorkflowTemplate(workflowId) {
+    const payload = await requestJson(`/api/taskforce/workflows/${encodeURIComponent(workflowId)}`);
+    if (!payload.workflow) {
+        throw new WorkflowManagerApiError('Workflow details were not returned.');
+    }
+    return payload.workflow;
+}
+export async function createWorkflowTemplate(input) {
+    const payload = await requestJson('/api/taskforce/workflows', {
+        method: 'POST',
+        body: JSON.stringify(input),
+    });
+    if (!payload.workflow) {
+        throw new WorkflowManagerApiError('The new workflow was not returned.');
+    }
+    return payload.workflow;
+}
+export async function saveWorkflowDraft(workflowId, input) {
+    const payload = await requestJson(`/api/taskforce/workflows/${encodeURIComponent(workflowId)}/draft`, { method: 'PUT', body: JSON.stringify(input) });
+    if (!payload.workflow)
+        throw new WorkflowManagerApiError('The saved workflow draft was not returned.');
+    return payload.workflow;
+}
+export async function publishWorkflowDraft(workflowId) {
+    const payload = await requestJson(`/api/taskforce/workflows/${encodeURIComponent(workflowId)}/publish`, { method: 'POST' });
+    if (!payload.workflow)
+        throw new WorkflowManagerApiError('The published workflow was not returned.');
+    return payload.workflow;
+}
+export async function createWorkflowDraft(workflowId) {
+    const payload = await requestJson(`/api/taskforce/workflows/${encodeURIComponent(workflowId)}/draft`, { method: 'POST' });
+    if (!payload.workflow)
+        throw new WorkflowManagerApiError('The new workflow draft was not returned.');
+    return payload.workflow;
+}
+export async function replaceWorkflowDraftSteps(workflowId, steps) {
+    const payload = await requestJson(`/api/taskforce/workflows/${encodeURIComponent(workflowId)}/draft/steps`, { method: 'PUT', body: JSON.stringify({ steps }) });
+    if (!payload.workflow)
+        throw new WorkflowManagerApiError('The updated workflow steps were not returned.');
+    return payload.workflow;
+}

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

@@ -4,17 +4,20 @@ import type { TaskAutoSaveState } from '../../hooks/tasks/useTaskFormActions';
 interface TaskActionHeaderProps {
     editingTaskId: string | null;
     loading: boolean;
+    submitDisabled?: boolean;
     autoSaveState?: TaskAutoSaveState;
     title: string;
+    status?: TaskStatus;
+    onStatusChange?: (status: TaskStatus) => void;
+    showCreateSubmit?: boolean;
     handleSubmit: (e: React.FormEvent | React.MouseEvent) => void;
-    resetForm: () => void;
     handleCopyId: (e: React.MouseEvent, id: string) => void;
     copiedId: string | null;
     tasks: TaskItem[];
     currentTask?: TaskItem;
     currentTaskWorkstream?: WorkstreamItem;
     currentTaskInitiative?: InitiativeItem;
-    workstreamInput?: string;
+    workstreams?: WorkstreamItem[];
     onWorkstreamInputChange?: (value: string) => void;
     onSetWorkstreamForCurrentTask?: (workstreamIdOverride?: string | null) => void;
     handleToggleInProgress: (task: TaskItem) => void;
@@ -26,6 +29,7 @@ interface TaskActionHeaderProps {
     handleUnarchiveTask?: (taskId: string) => void;
     handleRestoreDeletedTask?: (deletedRecordId: string) => void;
     handlePermanentlyDeleteDeletedTask?: (deletedRecordId: string) => void;
+    onAskAgent?: (task: TaskItem) => void;
 }
-export declare function TaskActionHeader({ editingTaskId, loading, autoSaveState, title, handleSubmit, resetForm, handleCopyId, copiedId, tasks, currentTask: currentTaskProp, currentTaskWorkstream, currentTaskInitiative, workstreamInput, onWorkstreamInputChange, onSetWorkstreamForCurrentTask, handleToggleInProgress, handleToggleReview, handleToggleComplete, handleToggleCancel, handleSetStatus, handleArchiveTask, handleUnarchiveTask, handleRestoreDeletedTask, handlePermanentlyDeleteDeletedTask }: TaskActionHeaderProps): import("react/jsx-runtime").JSX.Element;
+export declare function TaskActionHeader({ editingTaskId, loading, submitDisabled, autoSaveState, title, status, onStatusChange, showCreateSubmit, handleSubmit, handleCopyId, copiedId, tasks, currentTask: currentTaskProp, currentTaskWorkstream, currentTaskInitiative, workstreams, onWorkstreamInputChange, onSetWorkstreamForCurrentTask, handleToggleInProgress, handleToggleReview, handleToggleComplete, handleToggleCancel, handleSetStatus, handleArchiveTask, handleUnarchiveTask, handleRestoreDeletedTask, handlePermanentlyDeleteDeletedTask, onAskAgent }: TaskActionHeaderProps): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/components/task/TaskActionHeader.js

@@ -1,6 +1,6 @@
-import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
 import React from 'react';
-import { Check, Link2, Loader2, Plus, RotateCcw, Trash2, Unlink, X } from 'lucide-react';
+import { Bot, Loader2, Plus, RotateCcw, Trash2, Unlink } from 'lucide-react';
 import styles from '../../Taskforce.module.css';
 import { t } from '../../localization';
 import { TaskStatusActions } from './TaskStatusActions';
@@ -8,11 +8,17 @@ import { getTaskReferenceDisplayState } from '../../utils/taskReferences';
 import { TaskReferenceBadge } from './TaskReferenceBadge';
 import { HierarchyActionBadge } from '../ui/HierarchyActionBadge';
 import { formatInitiativeReference, getWorkstreamReferenceLabel } from '../../utils/planningReferences';
-export function TaskActionHeader({ editingTaskId, loading, autoSaveState = 'idle', title, handleSubmit, resetForm, handleCopyId, copiedId, tasks, currentTask: currentTaskProp, currentTaskWorkstream, currentTaskInitiative, workstreamInput = '', onWorkstreamInputChange, onSetWorkstreamForCurrentTask, handleToggleInProgress, handleToggleReview, handleToggleComplete, handleToggleCancel, handleSetStatus, handleArchiveTask, handleUnarchiveTask, handleRestoreDeletedTask, handlePermanentlyDeleteDeletedTask }) {
-    const [showWorkstreamEditor, setShowWorkstreamEditor] = React.useState(false);
+import { TaskWorkstreamPicker } from './TaskWorkstreamPicker';
+export function TaskActionHeader({ editingTaskId, loading, submitDisabled = false, autoSaveState = 'idle', title, status = 'task', onStatusChange, showCreateSubmit = true, handleSubmit, handleCopyId, copiedId, tasks, currentTask: currentTaskProp, currentTaskWorkstream, currentTaskInitiative, workstreams = [], onWorkstreamInputChange, onSetWorkstreamForCurrentTask, handleToggleInProgress, handleToggleReview, handleToggleComplete, handleToggleCancel, handleSetStatus, handleArchiveTask, handleUnarchiveTask, handleRestoreDeletedTask, handlePermanentlyDeleteDeletedTask, onAskAgent }) {
     const currentTask = currentTaskProp ?? (editingTaskId ? tasks.find(t => t.id === editingTaskId) || null : null);
     const isArchivedReadOnly = Boolean(currentTask?.isArchived);
     const isDeletedReadOnly = Boolean(currentTask?.isDeleted);
+    const deletedExpiryLabel = React.useMemo(() => {
+        if (!isDeletedReadOnly || !currentTask?.deletedExpiresAt)
+            return '';
+        const expiresAt = new Date(currentTask.deletedExpiresAt);
+        return Number.isNaN(expiresAt.getTime()) ? '' : `Trash expires ${expiresAt.toLocaleString()}`;
+    }, [currentTask?.deletedExpiresAt, isDeletedReadOnly]);
     const currentTaskReference = getTaskReferenceDisplayState(currentTask);
     const currentTaskReferenceLabel = currentTaskReference.label || (currentTaskReference.isProvisional ? 'Pending' : '');
     const currentTaskReferenceIsProvisional = currentTaskReference.isProvisional;
@@ -23,56 +29,43 @@ export function TaskActionHeader({ editingTaskId, loading, autoSaveState = 'idle
     const currentInitiativeReferenceLabel = currentTaskInitiative
         ? (formatInitiativeReference(currentTaskInitiative) || currentTaskInitiative.id)
         : '';
-    React.useEffect(() => {
-        if (currentTaskWorkstream) {
-            setShowWorkstreamEditor(false);
+    const handleWorkstreamSelect = React.useCallback((selectedWorkstream) => {
+        onWorkstreamInputChange?.(getWorkstreamReferenceLabel(selectedWorkstream) || selectedWorkstream.id);
+        if (editingTaskId) {
+            onSetWorkstreamForCurrentTask?.(selectedWorkstream.id);
         }
-    }, [currentTaskWorkstream?.id]);
-    const handleWorkstreamConfirm = React.useCallback(() => {
-        if (!workstreamInput.trim())
-            return;
-        onSetWorkstreamForCurrentTask?.();
-    }, [onSetWorkstreamForCurrentTask, workstreamInput]);
+    }, [editingTaskId, onSetWorkstreamForCurrentTask, onWorkstreamInputChange]);
     const handleWorkstreamRemove = React.useCallback(() => {
-        setShowWorkstreamEditor(false);
         onWorkstreamInputChange?.('');
-        onSetWorkstreamForCurrentTask?.(null);
-    }, [onSetWorkstreamForCurrentTask, onWorkstreamInputChange]);
-    return (_jsx("div", { className: styles.stickyActionHeader, children: editingTaskId ? (_jsxs(_Fragment, { children: [_jsxs("div", { className: styles.taskHierarchyHeader, children: [_jsxs("div", { className: styles.taskHierarchyBadgeRow, children: [currentTaskWorkstream ? (_jsx(_Fragment, { children: _jsx(HierarchyActionBadge, { onClick: handleWorkstreamRemove, disabled: loading || isArchivedReadOnly || isDeletedReadOnly, title: "Remove from workstream", ariaLabel: "Remove from workstream", children: _jsx(Unlink, { size: 13 }) }) })) : null, currentTaskInitiative ? (_jsxs("span", { className: styles.taskHierarchySegment, children: [_jsx("span", { className: styles.taskHierarchyDivider, children: "/" }), _jsx(TaskReferenceBadge, { copied: copiedId === currentInitiativeReferenceLabel, onClick: (e) => handleCopyId(e, currentInitiativeReferenceLabel), disabled: loading, title: "Copy initiative reference", label: currentInitiativeReferenceLabel })] })) : null, currentTaskWorkstream ? (_jsxs("span", { className: styles.taskHierarchySegment, children: [_jsx("span", { className: styles.taskHierarchyDivider, children: "/" }), _jsx(TaskReferenceBadge, { copied: copiedId === currentWorkstreamReferenceLabel, onClick: (e) => handleCopyId(e, currentWorkstreamReferenceLabel), disabled: loading, title: "Copy workstream reference", label: currentWorkstreamReferenceLabel })] })) : (_jsx(_Fragment, { children: _jsx(HierarchyActionBadge, { onClick: () => {
-                                            onWorkstreamInputChange?.('');
-                                            setShowWorkstreamEditor((value) => !value);
-                                        }, disabled: loading || isArchivedReadOnly || isDeletedReadOnly, title: "Attach to workstream", ariaLabel: "Attach to workstream", children: _jsx(Link2, { size: 13 }) }) })), currentTaskReferenceLabel ? (_jsxs("span", { className: styles.taskHierarchySegment, children: [_jsx("span", { className: styles.taskHierarchyDivider, children: "/" }), _jsx(TaskReferenceBadge, { copied: canCopyCurrentTaskReference && copiedId === currentTaskReference.label, onClick: (e) => handleCopyId(e, currentTaskReference.label), disabled: loading || !canCopyCurrentTaskReference, title: canCopyCurrentTaskReference ? t('actionHeader.copyTaskIdTitle') : 'Task reference pending sync', label: currentTaskReferenceLabel })] })) : null, currentTaskReferenceIsProvisional ? (_jsx("span", { className: styles.taskHierarchyMeta, title: "Temporary local reference until cloud sync assigns the final task number.", children: "Pending sync" })) : null] }), showWorkstreamEditor && !currentTaskWorkstream ? (_jsxs("div", { className: styles.taskHierarchyEditor, children: [_jsx("input", { type: "text", className: `${styles.input} ${styles.taskHierarchyInput}`, value: workstreamInput, onChange: (event) => onWorkstreamInputChange?.(event.target.value), placeholder: "WS-123", "aria-label": "Attach workstream reference", onKeyDown: (event) => {
-                                        if (event.key === 'Enter') {
-                                            event.preventDefault();
-                                            handleWorkstreamConfirm();
-                                        }
-                                        if (event.key === 'Escape') {
-                                            event.preventDefault();
-                                            onWorkstreamInputChange?.('');
-                                            setShowWorkstreamEditor(false);
-                                        }
-                                    } }), _jsx("button", { type: "button", className: "tf-control-icon tf-control-icon-compact", onClick: handleWorkstreamConfirm, disabled: !workstreamInput.trim() || loading, title: "Attach workstream", "aria-label": "Attach workstream", children: _jsx(Check, { size: 14 }) }), _jsx("button", { type: "button", className: "tf-control-icon tf-control-icon-compact", onClick: () => {
-                                        onWorkstreamInputChange?.('');
-                                        setShowWorkstreamEditor(false);
-                                    }, disabled: loading, title: "Cancel workstream attach", "aria-label": "Cancel workstream attach", children: _jsx(X, { size: 14 }) })] })) : null] }), _jsx("div", { className: styles.taskSaveStatusCenter, children: _jsx("div", { className: `${styles.taskSaveStatus} ${autoSaveState === 'error' ? styles.taskSaveStatusError : ''}`, "aria-live": "polite", children: autoSaveState === 'saving' ? (_jsxs(_Fragment, { children: [_jsx(Loader2, { size: 14, className: styles.spinner }), _jsx("span", { children: "Saving\u2026" })] })) : autoSaveState === 'saved' ? (_jsx("span", { children: "Saved" })) : autoSaveState === 'error' ? (_jsx("span", { children: "Save failed" })) : null }) }), _jsx("div", { className: styles.editActionsGroup, children: isDeletedReadOnly && currentTask?.deletedRecordId ? (_jsxs(_Fragment, { children: [handleRestoreDeletedTask && (_jsx("button", { type: "button", className: styles.actionBtn, onClick: () => handleRestoreDeletedTask(currentTask.deletedRecordId || ''), disabled: loading, title: "Restore deleted task", children: _jsx(RotateCcw, { size: 16 }) })), handlePermanentlyDeleteDeletedTask && (_jsx("button", { type: "button", className: `${styles.actionBtn} ${styles.deleteBtn}`, onClick: () => handlePermanentlyDeleteDeletedTask(currentTask.deletedRecordId || ''), disabled: loading, title: "Permanently delete deleted task", children: _jsx(Trash2, { size: 16 }) }))] })) : (_jsx(TaskStatusActions, { task: currentTask, disabled: loading, statusDisabled: loading || isArchivedReadOnly, archiveActionMode: isArchivedReadOnly ? 'unarchive' : 'auto', onSetStatus: (task, status) => {
-                            if (handleSetStatus) {
-                                handleSetStatus(task, status);
-                                return;
-                            }
-                            if (status === 'in-progress') {
-                                handleToggleInProgress(task);
-                                return;
-                            }
-                            if (status === 'review') {
-                                handleToggleReview(task);
-                                return;
-                            }
-                            if (status === 'done') {
-                                handleToggleComplete(task);
-                                return;
-                            }
-                            if (status === 'cancelled') {
-                                handleToggleCancel(task);
-                            }
-                        }, onArchiveTask: handleArchiveTask, onUnarchiveTask: (task) => handleUnarchiveTask?.(task.id) })) })] })) : (_jsxs(_Fragment, { children: [_jsxs("button", { type: "button", onClick: resetForm, disabled: loading, className: styles.secondaryHeaderBtn, title: t('actionHeader.clearFormTitle'), children: [_jsx(RotateCcw, { size: 16 }), t('actionHeader.clear')] }), _jsxs("button", { type: "button", onClick: (e) => handleSubmit(e), disabled: loading || !title.trim(), className: styles.primaryUpdateBtn, title: t('actionHeader.addTaskTitle'), children: [loading ? _jsx(Loader2, { size: 16, className: styles.spinner }) : _jsx(Plus, { size: 16 }), t('actionHeader.addTask')] })] })) }));
+        if (editingTaskId) {
+            onSetWorkstreamForCurrentTask?.(null);
+        }
+    }, [editingTaskId, onSetWorkstreamForCurrentTask, onWorkstreamInputChange]);
+    const unlinkWorkstreamButton = currentTaskWorkstream ? (_jsx(HierarchyActionBadge, { onClick: handleWorkstreamRemove, disabled: loading || isArchivedReadOnly || isDeletedReadOnly, title: "Unlink task from workstream", ariaLabel: "Unlink task from workstream", children: _jsx(Unlink, { size: 13 }) })) : null;
+    const taskHierarchyHeader = (_jsx("div", { className: styles.taskHierarchyHeader, children: _jsxs("div", { className: styles.taskHierarchyBadgeRow, children: [currentTaskInitiative ? (_jsx("span", { className: styles.taskHierarchySegment, children: _jsx(TaskReferenceBadge, { copied: copiedId === currentInitiativeReferenceLabel, onClick: (e) => handleCopyId(e, currentInitiativeReferenceLabel), disabled: loading, title: currentTaskInitiative.title, ariaLabel: `Copy initiative reference ${currentInitiativeReferenceLabel}: ${currentTaskInitiative.title}`, label: currentInitiativeReferenceLabel }) })) : null, currentTaskWorkstream ? (_jsxs("span", { className: styles.taskHierarchySegment, children: [currentTaskInitiative ? (_jsx("span", { className: styles.taskHierarchyDivider, children: "/" })) : null, _jsx(TaskReferenceBadge, { copied: copiedId === currentWorkstreamReferenceLabel, onClick: (e) => handleCopyId(e, currentWorkstreamReferenceLabel), disabled: loading, title: currentTaskWorkstream.title, ariaLabel: `Copy workstream reference ${currentWorkstreamReferenceLabel}: ${currentTaskWorkstream.title}`, label: currentWorkstreamReferenceLabel })] })) : (_jsx(TaskWorkstreamPicker, { workstreams: workstreams, onSelect: handleWorkstreamSelect, disabled: loading || isArchivedReadOnly || isDeletedReadOnly })), !currentTaskReferenceLabel && unlinkWorkstreamButton ? (_jsxs("span", { className: styles.taskHierarchySegment, children: [_jsx("span", { className: styles.taskHierarchyDivider, children: "/" }), unlinkWorkstreamButton] })) : null, currentTaskReferenceLabel ? (_jsxs("span", { className: styles.taskHierarchySegment, children: [currentTaskWorkstream ? (_jsx("span", { className: styles.taskHierarchyDivider, children: "/" })) : null, unlinkWorkstreamButton, _jsx(TaskReferenceBadge, { copied: canCopyCurrentTaskReference && copiedId === currentTaskReference.label, onClick: (e) => handleCopyId(e, currentTaskReference.label), disabled: loading || !canCopyCurrentTaskReference, title: currentTaskReferenceIsProvisional
+                                ? 'Temporary identifier — replaced after synchronization.'
+                                : t('actionHeader.copyTaskIdTitle'), ariaLabel: currentTaskReferenceIsProvisional
+                                ? `Copy temporary task reference ${currentTaskReferenceLabel}`
+                                : undefined, label: currentTaskReferenceLabel, provisional: currentTaskReferenceIsProvisional })] })) : null, deletedExpiryLabel ? (_jsx("span", { className: styles.taskHierarchyMeta, title: "Trash items are permanently deleted 90 days after deletion.", children: deletedExpiryLabel })) : null] }) }));
+    return (_jsxs("div", { className: styles.stickyActionHeader, children: [taskHierarchyHeader, editingTaskId ? (_jsxs(_Fragment, { children: [_jsx("div", { className: styles.taskSaveStatusCenter, children: _jsx("div", { className: `${styles.taskSaveStatus} ${autoSaveState === 'error' ? styles.taskSaveStatusError : ''}`, "aria-live": "polite", children: autoSaveState === 'saving' ? (_jsxs(_Fragment, { children: [_jsx(Loader2, { size: 14, className: styles.spinner }), _jsx("span", { children: "Saving\u2026" })] })) : autoSaveState === 'saved' ? (_jsx("span", { children: "Saved" })) : autoSaveState === 'error' ? (_jsx("span", { children: "Save failed" })) : null }) }), _jsxs("div", { className: styles.editActionsGroup, children: [onAskAgent && currentTask ? (_jsx("button", { type: "button", className: "tf-control-icon", onClick: () => onAskAgent(currentTask), disabled: loading, title: "Ask a Taskforce Agent about this task", "aria-label": "Ask a Taskforce Agent about this task", children: _jsx(Bot, { size: 16 }) })) : null, isDeletedReadOnly && currentTask?.deletedRecordId ? (_jsxs(_Fragment, { children: [handleRestoreDeletedTask && (_jsx("button", { type: "button", className: styles.actionBtn, onClick: () => handleRestoreDeletedTask(currentTask.deletedRecordId || ''), disabled: loading, title: "Restore deleted task", "aria-label": "Restore deleted task", children: _jsx(RotateCcw, { size: 16 }) })), handlePermanentlyDeleteDeletedTask && (_jsx("button", { type: "button", className: `${styles.actionBtn} ${styles.deleteBtn}`, onClick: () => handlePermanentlyDeleteDeletedTask(currentTask.deletedRecordId || ''), disabled: loading, title: "Permanently delete deleted task", "aria-label": "Permanently delete deleted task", children: _jsx(Trash2, { size: 16 }) }))] })) : (_jsx(TaskStatusActions, { task: currentTask, disabled: loading, statusDisabled: loading || isArchivedReadOnly, archiveActionMode: isArchivedReadOnly ? 'unarchive' : 'auto', onSetStatus: (task, status) => {
+                                    if (handleSetStatus) {
+                                        handleSetStatus(task, status);
+                                        return;
+                                    }
+                                    if (status === 'in-progress') {
+                                        handleToggleInProgress(task);
+                                        return;
+                                    }
+                                    if (status === 'review') {
+                                        handleToggleReview(task);
+                                        return;
+                                    }
+                                    if (status === 'done') {
+                                        handleToggleComplete(task);
+                                        return;
+                                    }
+                                    if (status === 'cancelled') {
+                                        handleToggleCancel(task);
+                                    }
+                                }, onArchiveTask: handleArchiveTask, onUnarchiveTask: (task) => handleUnarchiveTask?.(task.id) }))] })] })) : (_jsxs(_Fragment, { children: [_jsx("div", { className: styles.taskSaveStatusCenter }), _jsxs("div", { className: styles.editActionsGroup, children: [_jsx(TaskStatusActions, { status: status, disabled: loading, archiveActionMode: "none", onStatusChange: onStatusChange }), showCreateSubmit ? (_jsxs("button", { type: "button", onClick: (e) => handleSubmit(e), disabled: loading || submitDisabled || !title.trim(), className: styles.primaryUpdateBtn, title: t('actionHeader.addTaskTitle'), children: [loading ? _jsx(Loader2, { size: 16, className: styles.spinner }) : _jsx(Plus, { size: 16 }), t('actionHeader.addTask')] })) : null] })] }))] }));
 }

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

@@ -1,5 +1,6 @@
 import React from 'react';
-import type { TaskItem, TaxonomyDefinition, CategoryConfig, WorkstreamItem, InitiativeItem } from '../../types';
+import type { TaskItem, TaxonomyDefinition, CategoryConfig, WorkstreamItem, InitiativeItem, TaskAssignee } from '../../types';
+import { type TaskReferenceContract } from '../../utils/taskReferences';
 import { type TaskAssigneeOption } from '../../utils/assignees';
 interface TaskCardProps {
     task: TaskItem;
@@ -20,12 +21,17 @@ interface TaskCardProps {
     }>;
     categories?: CategoryConfig[];
     assigneeOptions?: TaskAssigneeOption[];
+    workstreams?: WorkstreamItem[];
     taskWorkstream?: WorkstreamItem | null;
     taskInitiative?: InitiativeItem | null;
+    workspaceId?: string | null;
     isOverlay?: boolean;
     isArchived?: boolean;
     readOnlyMode?: 'archived' | 'deleted' | null;
     isRecentlyChanged?: boolean;
+    selectable?: boolean;
+    selected?: boolean;
+    onSelectionChange?: (selected: boolean) => void;
     onClick?: (task: TaskItem) => void;
     onCopyId?: (e: React.MouseEvent, id: string) => void;
     onToggleInProgress?: (task: TaskItem) => void;
@@ -37,7 +43,9 @@ interface TaskCardProps {
     onUnarchive?: (taskId: string) => void;
     onDelete?: (taskId: string) => void;
     deleteActionTitle?: string;
-    onOpenTaskById?: (taskId: string) => void;
+    taskReferences?: TaskReferenceContract;
+    onAssigneeChange?: (task: TaskItem, assignee: TaskAssignee) => void;
+    onWorkstreamChange?: (task: TaskItem, workstreamId: string | null) => boolean | void | Promise<boolean | void>;
     compressed?: boolean;
     showStatusLabel?: boolean;
 }