@taskforcehq/taskforce 0.3.328 → 0.3.330

package/dist/hooks/useTaskMutations.js

@@ -36,11 +36,12 @@ function taskHttpObservedPrecondition(task, taskId) {
     return {
         taskId,
         updatedAt: task?.updatedAt ?? null,
+        detailRevision: task?.detailRevision ?? null,
         status: task?.status ?? null,
         isArchived: task?.isArchived === true,
     };
 }
-export function useTaskMutations({ tasks, archivedTasks, editingTaskId, setTasks, setArchivedTasks, setDeletedTasks, setError, resetForm, setActiveTab, fetchTasks, fetchArchive, fetchDeletedTasks, mergeTaskFromServer, pushNotice, cloudAuthConfigured, runtimeMode, isAuthenticated, workspaceCloudSyncEnabled, buildWorkspaceSyncSignature, pushWorkspaceChangesToCloud, workspacePendingSignatureRef, workspaceDeletedTaskIdsRef, workspaceDeletedTaskWatermarksRef, mutateTaskMetadata, mutateTaskStatus, mutateTaskLifecycle, mutateTaskDelete, mutateTaskRestore, durableTaskMetadataActivationEnabled = false, durableTaskStatusActivationEnabled = false, durableTaskDeleteActivationEnabled = false, durableTaskHttpRootActivationEnabled = false, workspaceId = 'default', taskHttpMutationClient, }) {
+export function useTaskMutations({ tasks, archivedTasks, editingTaskId, editingTaskDetailRevision = null, setTasks, setArchivedTasks, setDeletedTasks, setError, resetForm, setActiveTab, fetchTasks, fetchArchive, fetchDeletedTasks, mergeTaskFromServer, pushNotice, cloudAuthConfigured, runtimeMode, isAuthenticated, workspaceCloudSyncEnabled, buildWorkspaceSyncSignature, pushWorkspaceChangesToCloud, workspacePendingSignatureRef, workspaceDeletedTaskIdsRef, workspaceDeletedTaskWatermarksRef, mutateTaskMetadata, mutateTaskStatus, mutateTaskLifecycle, mutateTaskDelete, mutateTaskRestore, durableTaskMetadataActivationEnabled = false, durableTaskStatusActivationEnabled = false, durableTaskDeleteActivationEnabled = false, durableTaskHttpRootActivationEnabled = false, workspaceId = 'default', taskHttpMutationClient, onTaskRevisionConflict, onTaskMutationAccepted, pendingTaskMetadataOverlaysRef, }) {
     const authoritativeTaskSnapshotsRef = useRef(new Map());
     useEffect(() => {
         if (typeof window === 'undefined')
@@ -418,8 +419,10 @@ export function useTaskMutations({ tasks, archivedTasks, editingTaskId, setTasks
             pushNotice(message, 'error');
             return true;
         }
-        if ('task' in result && result.task)
+        if ('task' in result && result.task) {
             mergeTaskFromServer(result.task);
+            onTaskMutationAccepted?.(result.task);
+        }
         if (result.state === 'accepted') {
             setError('');
         }
@@ -441,8 +444,10 @@ export function useTaskMutations({ tasks, archivedTasks, editingTaskId, setTasks
             pushNotice(message, 'error');
         }
         return true;
-    }, [mergeTaskFromServer, pushNotice, setArchivedTasks, setError, setTasks]);
-    const handleSetStatus = useCallback(async (task, status, updates = {}) => {
+    }, [mergeTaskFromServer, onTaskMutationAccepted, pushNotice, setArchivedTasks, setError, setTasks]);
+    const handleSetStatus = useCallback(async (task, status, updates = {}, expectedDetailRevisionOverride) => {
+        const expectedDetailRevision = expectedDetailRevisionOverride
+            ?? (task.id === editingTaskId ? editingTaskDetailRevision : null);
         const containsDurableMetadata = Object.keys(updates)
             .some((key) => DURABLE_TASK_METADATA_FIELD_NAMES.has(key));
         const unsupportedFields = Object.keys(updates).filter((key) => (!TASK_STATUS_CONTROL_FIELDS.has(key) && !DURABLE_TASK_METADATA_FIELD_NAMES.has(key)));
@@ -468,17 +473,55 @@ export function useTaskMutations({ tasks, archivedTasks, editingTaskId, setTasks
         setArchivedTasks((current) => current.map((item) => item.id === task.id ? { ...item, ...optimisticPatch } : item));
         if (mutateTaskStatus) {
             try {
-                const assigneeIntent = Object.prototype.hasOwnProperty.call(updates, 'assignee')
-                    ? { kind: 'set', value: updates.assignee ?? null }
-                    : { kind: 'preserve' };
-                const metadataPatch = selectDurableTaskMetadataPatch(updates);
-                delete metadataPatch.assignee;
-                const durableResult = await mutateTaskStatus(task.id, {
-                    status,
-                    assigneeIntent,
-                    canceledReason: status === 'cancelled' ? (updates.canceledReason ?? null) : null,
-                    metadataPatch,
-                });
+                const buildDurablePayload = (targetStatus, targetUpdates, detailRevision) => {
+                    const assigneeIntent = Object.prototype.hasOwnProperty.call(targetUpdates, 'assignee')
+                        ? { kind: 'set', value: targetUpdates.assignee ?? null }
+                        : { kind: 'preserve' };
+                    const metadataPatch = selectDurableTaskMetadataPatch(targetUpdates);
+                    delete metadataPatch.assignee;
+                    return {
+                        status: targetStatus,
+                        assigneeIntent,
+                        canceledReason: targetStatus === 'cancelled'
+                            ? (targetUpdates.canceledReason ?? null)
+                            : null,
+                        metadataPatch,
+                        ...(detailRevision ? { expectedDetailRevision: detailRevision } : {}),
+                    };
+                };
+                let durableResult = await mutateTaskStatus(task.id, buildDurablePayload(status, updates, expectedDetailRevision));
+                if (durableResult
+                    && (durableResult.state === 'rejected' || durableResult.state === 'failed')
+                    && durableResult.errorCode === 'TASK_DETAIL_REVISION_CONFLICT') {
+                    const previousTask = previousTasks.find((item) => item.id === task.id)
+                        || previousArchivedTasks.find((item) => item.id === task.id);
+                    setTasks((current) => rollbackTargetTaskPatch(current, previousTask, task.id, optimisticPatch));
+                    setArchivedTasks((current) => rollbackTargetTaskPatch(current, previousTask, task.id, optimisticPatch));
+                    const resolution = await onTaskRevisionConflict?.(task.id, null);
+                    if (resolution?.retryDetailRevision) {
+                        const retryPatch = Object.fromEntries(Object.entries(updates).map(([key, value]) => [
+                            key,
+                            resolution.retryPatch && Object.prototype.hasOwnProperty.call(resolution.retryPatch, key)
+                                ? resolution.retryPatch[key]
+                                : value,
+                        ]));
+                        const retryStatus = (resolution.retryPatch?.status || status);
+                        durableResult = await mutateTaskStatus(task.id, buildDurablePayload(retryStatus, retryPatch, resolution.retryDetailRevision));
+                        if (durableResult
+                            && (durableResult.state === 'rejected' || durableResult.state === 'failed')
+                            && durableResult.errorCode === 'TASK_DETAIL_REVISION_CONFLICT') {
+                            const secondResolution = await onTaskRevisionConflict?.(task.id, null);
+                            if (secondResolution?.handled) {
+                                setError('');
+                                return;
+                            }
+                        }
+                    }
+                    else if (resolution?.handled) {
+                        setError('');
+                        return;
+                    }
+                }
                 if (durableResult && finishDurableTaskMutation(durableResult, task.id, optimisticPatch, previousTasks, previousArchivedTasks))
                     return;
                 if (!durableResult && durableTaskStatusActivationEnabled) {
@@ -515,15 +558,54 @@ export function useTaskMutations({ tasks, archivedTasks, editingTaskId, setTasks
             return;
         }
         try {
-            const legacyPatch = { ...updates, status, completedAt: optimisticPatch.completedAt };
-            const requestInit = {
-                method: 'PATCH',
-                headers: { 'Content-Type': 'application/json' },
-                body: JSON.stringify(legacyPatch),
+            const legacyPatch = {
+                ...updates,
+                status,
+                completedAt: optimisticPatch.completedAt,
+                ...(expectedDetailRevision ? { expectedDetailRevision } : {}),
             };
-            const res = await fetchCloudTaskRootPatch(`/api/taskforce/task/${task.id}`, requestInit, legacyPatch, task.id, taskHttpObservedPrecondition(task, task.id));
+            let activePatch = legacyPatch;
+            let res;
+            let data = {};
+            for (let attempt = 0;; attempt += 1) {
+                res = await fetchCloudTaskRootPatch(`/api/taskforce/task/${task.id}`, {
+                    method: 'PATCH',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify(activePatch),
+                }, activePatch, task.id, taskHttpObservedPrecondition(task, task.id));
+                if (res.ok)
+                    break;
+                data = await res.json().catch(() => ({}));
+                if (data.code !== 'TASK_DETAIL_REVISION_CONFLICT')
+                    break;
+                setTasks(previousTasks);
+                setArchivedTasks(previousArchivedTasks);
+                const currentDetailRevision = typeof data?.details?.currentDetailRevision === 'string'
+                    ? data.details.currentDetailRevision
+                    : null;
+                const resolution = await onTaskRevisionConflict?.(task.id, currentDetailRevision);
+                if (attempt === 0 && resolution?.retryDetailRevision) {
+                    const retryPatch = Object.fromEntries(Object.entries(legacyPatch).map(([key, value]) => [
+                        key,
+                        resolution.retryPatch && Object.prototype.hasOwnProperty.call(resolution.retryPatch, key)
+                            ? resolution.retryPatch[key]
+                            : value,
+                    ]));
+                    activePatch = {
+                        ...retryPatch,
+                        expectedDetailRevision: resolution.retryDetailRevision,
+                    };
+                    continue;
+                }
+                if (resolution?.handled) {
+                    setError('');
+                    return;
+                }
+                break;
+            }
             if (!res.ok) {
-                const data = await res.json().catch(() => ({}));
+                if (Object.keys(data).length === 0)
+                    data = await res.json().catch(() => ({}));
                 const message = data.error || 'Failed to update task status.';
                 setError(message);
                 pushNotice(message, 'error');
@@ -532,8 +614,10 @@ export function useTaskMutations({ tasks, archivedTasks, editingTaskId, setTasks
                 return;
             }
             const updatedTask = await res.json().catch(() => null);
-            if (updatedTask)
+            if (updatedTask) {
                 mergeTaskFromServer(updatedTask);
+                onTaskMutationAccepted?.(updatedTask);
+            }
             else
                 await fetchTasks(true);
             queueWorkspaceSyncFromAuthoritativeTaskState();
@@ -549,6 +633,8 @@ export function useTaskMutations({ tasks, archivedTasks, editingTaskId, setTasks
     }, [
         archivedTasks,
         durableTaskMetadataActivationEnabled,
+        editingTaskDetailRevision,
+        editingTaskId,
         durableTaskHttpRootActivationEnabled,
         durableTaskStatusActivationEnabled,
         fetchTasks,
@@ -556,6 +642,8 @@ export function useTaskMutations({ tasks, archivedTasks, editingTaskId, setTasks
         finishDurableTaskMutation,
         mergeTaskFromServer,
         mutateTaskStatus,
+        onTaskMutationAccepted,
+        onTaskRevisionConflict,
         pushNotice,
         queueWorkspaceSyncFromAuthoritativeTaskState,
         setArchivedTasks,
@@ -564,8 +652,14 @@ export function useTaskMutations({ tasks, archivedTasks, editingTaskId, setTasks
         tasks,
     ]);
     const handleUpdateTask = useCallback(async (id, updates) => {
-        const saveSource = updates.saveSource;
-        updates = Object.fromEntries(Object.entries(updates).filter(([key]) => key !== 'saveSource'));
+        const specialFields = updates;
+        const saveSource = specialFields.saveSource;
+        const expectedDetailRevision = typeof specialFields.expectedDetailRevision === 'string'
+            ? specialFields.expectedDetailRevision
+            : id === editingTaskId
+                ? editingTaskDetailRevision
+                : null;
+        updates = Object.fromEntries(Object.entries(updates).filter(([key]) => (key !== 'saveSource' && key !== 'expectedDetailRevision')));
         if (Object.keys(updates).length === 0)
             return true;
         const authoritativeTask = authoritativeTaskSnapshotsRef.current.get(id);
@@ -589,7 +683,7 @@ export function useTaskMutations({ tasks, archivedTasks, editingTaskId, setTasks
         if (updates.status) {
             const target = tasks.find((task) => task.id === id) || archivedTasks.find((task) => task.id === id);
             if (target) {
-                await handleSetStatus(target, updates.status, updates);
+                await handleSetStatus(target, updates.status, updates, expectedDetailRevision);
                 return;
             }
             if (durableTaskStatusActivationEnabled) {
@@ -609,12 +703,80 @@ export function useTaskMutations({ tasks, archivedTasks, editingTaskId, setTasks
         let hasLegacyCarriers = Object.keys(legacyCarrierPatch).length > 0;
         let durableMetadataHandled = false;
         if (hasDurableMetadata && mutateTaskMetadata) {
+            const pendingOverlay = {
+                patch: durableMetadataPatch,
+                observedUpdatedAt: observedTask?.updatedAt || null,
+            };
+            pendingTaskMetadataOverlaysRef?.current.set(id, pendingOverlay);
+            const clearPendingOverlay = () => {
+                if (pendingTaskMetadataOverlaysRef?.current.get(id) === pendingOverlay) {
+                    pendingTaskMetadataOverlaysRef.current.delete(id);
+                }
+            };
+            const ownsPendingOverlay = () => (!pendingTaskMetadataOverlaysRef
+                || pendingTaskMetadataOverlaysRef.current.get(id) === pendingOverlay);
             try {
-                const durableResult = saveSource
-                    ? await mutateTaskMetadata(id, durableMetadataPatch, { saveSource })
+                const initialMutationOptions = {
+                    ...(saveSource ? { saveSource } : {}),
+                    ...(expectedDetailRevision ? { expectedDetailRevision } : {}),
+                };
+                let durableResult = Object.keys(initialMutationOptions).length > 0
+                    ? await mutateTaskMetadata(id, durableMetadataPatch, initialMutationOptions)
                     : await mutateTaskMetadata(id, durableMetadataPatch);
+                if (!ownsPendingOverlay())
+                    return false;
                 if (durableResult && durableResult.state !== 'disabled') {
+                    if ((durableResult.state === 'rejected' || durableResult.state === 'failed')
+                        && durableResult.errorCode === 'TASK_DETAIL_REVISION_CONFLICT') {
+                        const previousTask = previousTasks.find((task) => task.id === id)
+                            || previousArchivedTasks.find((task) => task.id === id);
+                        setTasks((currentTasks) => rollbackTargetTaskPatch(currentTasks, previousTask, id, updates));
+                        setArchivedTasks((currentTasks) => rollbackTargetTaskPatch(currentTasks, previousTask, id, updates));
+                        const resolution = await onTaskRevisionConflict?.(id, null);
+                        if (!ownsPendingOverlay())
+                            return false;
+                        if (resolution?.retryDetailRevision) {
+                            const reconciledPatch = resolution.retryPatch;
+                            const retryMetadataPatch = Object.fromEntries(Object.entries(durableMetadataPatch).map(([key, value]) => [
+                                key,
+                                reconciledPatch && Object.prototype.hasOwnProperty.call(reconciledPatch, key)
+                                    ? reconciledPatch[key]
+                                    : value,
+                            ]));
+                            pendingOverlay.patch = retryMetadataPatch;
+                            durableResult = await mutateTaskMetadata(id, retryMetadataPatch, {
+                                ...(saveSource ? { saveSource } : {}),
+                                expectedDetailRevision: resolution.retryDetailRevision,
+                            });
+                            if (!ownsPendingOverlay())
+                                return false;
+                            if (durableResult
+                                && (durableResult.state === 'rejected' || durableResult.state === 'failed')
+                                && durableResult.errorCode === 'TASK_DETAIL_REVISION_CONFLICT') {
+                                const secondResolution = await onTaskRevisionConflict?.(id, null);
+                                if (secondResolution?.handled) {
+                                    setError('');
+                                    return false;
+                                }
+                            }
+                        }
+                        else if (resolution?.handled) {
+                            setError('');
+                            return false;
+                        }
+                    }
+                    if (!durableResult || durableResult.state === 'disabled') {
+                        const previousTask = previousTasks.find((task) => task.id === id)
+                            || previousArchivedTasks.find((task) => task.id === id);
+                        setTasks((currentTasks) => rollbackTargetTaskPatch(currentTasks, previousTask, id, updates));
+                        setArchivedTasks((currentTasks) => rollbackTargetTaskPatch(currentTasks, previousTask, id, updates));
+                        const message = 'Task was not saved because durable metadata capture became unavailable during retry.';
+                        setError(message);
+                        pushNotice(message, 'error');
+                        return false;
+                    }
                     if (durableResult.state === 'rejected' || durableResult.state === 'failed') {
+                        clearPendingOverlay();
                         const previousTask = previousTasks.find((task) => task.id === id)
                             || previousArchivedTasks.find((task) => task.id === id);
                         setTasks((currentTasks) => rollbackTargetTaskPatch(currentTasks, previousTask, id, updates));
@@ -629,8 +791,18 @@ export function useTaskMutations({ tasks, archivedTasks, editingTaskId, setTasks
                         return false;
                     }
                     durableMetadataHandled = true;
-                    if ('task' in durableResult && durableResult.task)
+                    if ('task' in durableResult
+                        && durableResult.task?.updatedAt
+                        && pendingTaskMetadataOverlaysRef?.current.get(id) === pendingOverlay) {
+                        pendingOverlay.observedUpdatedAt = durableResult.task.updatedAt;
+                    }
+                    if ('task' in durableResult
+                        && durableResult.task
+                        && (!pendingTaskMetadataOverlaysRef
+                            || pendingTaskMetadataOverlaysRef.current.get(id) === pendingOverlay)) {
                         mergeTaskFromServer(durableResult.task);
+                        onTaskMutationAccepted?.(durableResult.task);
+                    }
                     if (durableResult.state === 'accepted') {
                         setError('');
                     }
@@ -663,18 +835,24 @@ export function useTaskMutations({ tasks, archivedTasks, editingTaskId, setTasks
                     if (!hasLegacyCarriers)
                         return true;
                 }
-                else if (durableTaskMetadataActivationEnabled) {
-                    const previousTask = previousTasks.find((task) => task.id === id)
-                        || previousArchivedTasks.find((task) => task.id === id);
-                    setTasks((currentTasks) => rollbackTargetTaskPatch(currentTasks, previousTask, id, updates));
-                    setArchivedTasks((currentTasks) => rollbackTargetTaskPatch(currentTasks, previousTask, id, updates));
-                    const message = 'Task was not saved because durable metadata capture was unavailable.';
-                    setError(message);
-                    pushNotice(message, 'error');
-                    return false;
+                else {
+                    clearPendingOverlay();
+                    if (durableTaskMetadataActivationEnabled) {
+                        const previousTask = previousTasks.find((task) => task.id === id)
+                            || previousArchivedTasks.find((task) => task.id === id);
+                        setTasks((currentTasks) => rollbackTargetTaskPatch(currentTasks, previousTask, id, updates));
+                        setArchivedTasks((currentTasks) => rollbackTargetTaskPatch(currentTasks, previousTask, id, updates));
+                        const message = 'Task was not saved because durable metadata capture was unavailable.';
+                        setError(message);
+                        pushNotice(message, 'error');
+                        return false;
+                    }
                 }
             }
             catch (error) {
+                if (!ownsPendingOverlay())
+                    return false;
+                clearPendingOverlay();
                 console.error('Durable task metadata update failed before a conclusive result.', error);
                 if (hasLegacyCarriers) {
                     const previousTask = previousTasks.find((task) => task.id === id)
@@ -708,32 +886,68 @@ export function useTaskMutations({ tasks, archivedTasks, editingTaskId, setTasks
             const legacyRequestPatch = {
                 ...legacyCarrierPatch,
                 ...(saveSource ? { saveSource } : {}),
+                ...(expectedDetailRevision ? { expectedDetailRevision } : {}),
             };
             const requestInit = {
                 method: 'PATCH',
                 headers: { 'Content-Type': 'application/json' },
                 body: JSON.stringify(legacyRequestPatch),
             };
-            const res = await fetchCloudTaskRootPatch(`/api/taskforce/task/${id}`, requestInit, legacyRequestPatch, id, taskHttpObservedPrecondition(previousTasks.find((task) => task.id === id)
-                || previousArchivedTasks.find((task) => task.id === id), id));
-            if (!res.ok) {
+            let activeRequestPatch = legacyRequestPatch;
+            for (let attempt = 0; attempt < 2; attempt += 1) {
+                const activeRequestInit = attempt === 0 ? requestInit : {
+                    ...requestInit,
+                    body: JSON.stringify(activeRequestPatch),
+                };
+                const res = await fetchCloudTaskRootPatch(`/api/taskforce/task/${id}`, activeRequestInit, activeRequestPatch, id, taskHttpObservedPrecondition(previousTasks.find((task) => task.id === id)
+                    || previousArchivedTasks.find((task) => task.id === id), id));
+                if (res.ok) {
+                    const updatedTask = await res.json().catch(() => null);
+                    mergeTaskFromServer(updatedTask);
+                    if (updatedTask && typeof updatedTask === 'object' && typeof updatedTask.id === 'string') {
+                        onTaskMutationAccepted?.(updatedTask);
+                    }
+                    // Attachment saves also depend on the canonical asset snapshot refresh. Give that
+                    // snapshot a brief head start so the next push includes both task metadata and bytes.
+                    queueWorkspaceSyncFromAuthoritativeTaskState(updates.attachments !== undefined ? 150 : 0);
+                    setError('');
+                    return true;
+                }
                 const data = await res.json().catch(() => ({}));
-                const message = data.error || `Failed to update task ${id}.`;
-                setError(message);
-                pushNotice(message, 'error');
                 const previousTask = previousTasks.find((task) => task.id === id)
                     || previousArchivedTasks.find((task) => task.id === id);
                 setTasks((currentTasks) => rollbackTargetTaskPatch(currentTasks, previousTask, id, legacyCarrierPatch));
                 setArchivedTasks((currentTasks) => rollbackTargetTaskPatch(currentTasks, previousTask, id, legacyCarrierPatch));
+                if (data.code === 'TASK_DETAIL_REVISION_CONFLICT') {
+                    const currentDetailRevision = typeof data?.details?.currentDetailRevision === 'string'
+                        ? data.details.currentDetailRevision
+                        : null;
+                    const resolution = await onTaskRevisionConflict?.(id, currentDetailRevision);
+                    if (attempt === 0 && resolution?.retryDetailRevision) {
+                        const reconciledPatch = resolution.retryPatch;
+                        const retryPatch = Object.fromEntries(Object.entries(legacyRequestPatch).map(([key, value]) => [
+                            key,
+                            reconciledPatch && Object.prototype.hasOwnProperty.call(reconciledPatch, key)
+                                ? reconciledPatch[key]
+                                : value,
+                        ]));
+                        activeRequestPatch = {
+                            ...retryPatch,
+                            expectedDetailRevision: resolution.retryDetailRevision,
+                        };
+                        continue;
+                    }
+                    if (resolution?.handled) {
+                        setError('');
+                        return false;
+                    }
+                }
+                const message = data.error || `Failed to update task ${id}.`;
+                setError(message);
+                pushNotice(message, 'error');
                 return false;
             }
-            const updatedTask = await res.json().catch(() => null);
-            mergeTaskFromServer(updatedTask);
-            // Attachment saves also depend on the canonical asset snapshot refresh. Give that
-            // snapshot a brief head start so the next push includes both task metadata and bytes.
-            queueWorkspaceSyncFromAuthoritativeTaskState(updates.attachments !== undefined ? 150 : 0);
-            setError('');
-            return true;
+            return false;
         }
         catch (err) {
             console.error("Failed to update task", err);
@@ -746,7 +960,7 @@ export function useTaskMutations({ tasks, archivedTasks, editingTaskId, setTasks
             setArchivedTasks((currentTasks) => rollbackTargetTaskPatch(currentTasks, previousTask, id, legacyCarrierPatch));
             return false;
         }
-    }, [tasks, archivedTasks, pushNotice, mergeTaskFromServer, mutateTaskMetadata, queueWorkspaceSyncFromAuthoritativeTaskState, handleSetStatus, durableTaskMetadataActivationEnabled, durableTaskStatusActivationEnabled, fetchCloudTaskRootPatch]);
+    }, [tasks, archivedTasks, editingTaskDetailRevision, editingTaskId, pushNotice, mergeTaskFromServer, mutateTaskMetadata, onTaskMutationAccepted, onTaskRevisionConflict, pendingTaskMetadataOverlaysRef, queueWorkspaceSyncFromAuthoritativeTaskState, handleSetStatus, durableTaskMetadataActivationEnabled, durableTaskStatusActivationEnabled, fetchCloudTaskRootPatch]);
     const handleToggleComplete = async (task) => {
         const newStatus = task.status === 'done' ? 'task' : 'done';
         await handleSetStatus(task, newStatus);

package/dist/hooks/useTaskforce.d.ts

@@ -38,6 +38,7 @@ import type { PlanningIdentityColor, PlanningIdentityIcon } from '../shared/plan
 import type { UiNotice } from '../utils/uiNotice';
 import type { TaskAssigneeOption } from '../utils/assignees';
 import { type WorkspaceModuleId } from './workspace/workspaceLocalState';
+export declare function buildRelationshipTasks(tasks: TaskItem[], archivedTasks: TaskItem[], taskDetails: TaskItem[], editingTaskId: string | null): TaskItem[];
 export interface UseTaskforceProps {
     config?: Partial<TaskforceConfig>;
     initialTaskId?: string;
@@ -108,6 +109,7 @@ export declare function sanitizePlanningBootstrapPayload(input: unknown): Planni
 export declare function useTaskforce({ config, initialTaskId, initialActivityEntryId, requestedWorkspaceId, onTaskCountChange, onClose }: UseTaskforceProps): {
     config: {
         cloudEnvironment: any;
+        appGates: any;
         apiBaseUrl: string | undefined;
         cloudAuthBaseUrl: string | undefined;
         wsBaseUrl: string | undefined;
@@ -136,6 +138,11 @@ export declare function useTaskforce({ config, initialTaskId, initialActivityEnt
         manualComplexityEnabled: boolean;
         checklistDropdownEnabled: boolean;
         showTaskCardStatusLabel: boolean;
+        showTaskCardDescription: boolean;
+        showTaskCardAttachments: boolean;
+        showTaskCardChecklistProgress: boolean;
+        showTaskCardLatestActivity: boolean;
+        tintTaskCardActivityBackground: boolean;
     };
     isOpen: boolean;
     setIsOpen: Dispatch<SetStateAction<boolean>>;
@@ -158,11 +165,16 @@ export declare function useTaskforce({ config, initialTaskId, initialActivityEnt
     manualComplexityEnabled: boolean;
     checklistDropdownEnabled: boolean;
     showTaskCardStatusLabel: boolean;
+    showTaskCardDescription: boolean;
+    showTaskCardAttachments: boolean;
+    showTaskCardChecklistProgress: boolean;
+    showTaskCardLatestActivity: boolean;
+    tintTaskCardActivityBackground: boolean;
     setManualComplexityEnabled: Dispatch<SetStateAction<boolean>>;
     mcpHostRoot: string;
     setMcpHostRoot: Dispatch<SetStateAction<string>>;
-    settingsSection: "mcp" | "categories" | "types" | "general" | "agents" | "taxonomy" | "documents" | "appearance-application" | "appearance-task-cards" | "appearance-task-forms" | "integrations" | null;
-    setSettingsSection: Dispatch<SetStateAction<"mcp" | "categories" | "types" | "general" | "agents" | "taxonomy" | "documents" | "appearance-application" | "appearance-task-cards" | "appearance-task-forms" | "integrations" | null>>;
+    settingsSection: "mcp" | "categories" | "types" | "general" | "documents" | "taxonomy" | "agents" | "appearance-application" | "appearance-task-cards" | "appearance-task-forms" | "integrations" | null;
+    setSettingsSection: Dispatch<SetStateAction<"mcp" | "categories" | "types" | "general" | "documents" | "taxonomy" | "agents" | "appearance-application" | "appearance-task-cards" | "appearance-task-forms" | "integrations" | null>>;
     runtimeMode: "local" | "cloud";
     workspaceMode: "single-local" | "multi-cloud";
     workspaceSwitchingEnabled: boolean;
@@ -193,6 +205,8 @@ export declare function useTaskforce({ config, initialTaskId, initialActivityEnt
         phase: import("./sync/useLocalSyncCoordinatorSnapshot").LocalSyncCoordinatorSnapshotPhase;
         snapshot: import("../sync/coordinator/localSyncCoordinatorBrowserClient").LocalSyncCoordinatorStatusResponse | null;
         errorMessage: string | null;
+        activeCommandType: import("../sync/coordinator/localSyncCoordinatorTypes").LocalSyncCoordinatorCommandType | null;
+        activePriorityCommandType: import("../sync/coordinator/localSyncCoordinatorTypes").LocalSyncCoordinatorCommandType | null;
     } | null;
     transferLocalCoordinatorOwnership: (targetMode: "server" | "browser-gateway") => Promise<boolean>;
     retryUserGlobalSettingsSync: () => Promise<void>;
@@ -244,7 +258,7 @@ export declare function useTaskforce({ config, initialTaskId, initialActivityEnt
     realtimeSyncEnabled: boolean;
     realtimeSyncFlagSource: "default" | "unknown" | "settings" | "env";
     currentWorkspaceId: string;
-    currentWorkspaceRole: "member" | "owner" | "admin" | "read-only" | null;
+    currentWorkspaceRole: "owner" | "member" | "admin" | "read-only" | null;
     availableWorkspaces: WorkspaceSummary[];
     assigneeOptions: TaskAssigneeOption[];
     workspaceCloudSyncEnabled: boolean;
@@ -446,8 +460,8 @@ export declare function useTaskforce({ config, initialTaskId, initialActivityEnt
         type: "category";
         value: string;
     } | null>>;
-    groupBy: "category" | "type" | "priority" | "status" | "complexity" | "assignee" | "schedule";
-    setGroupBy: Dispatch<SetStateAction<"category" | "type" | "priority" | "status" | "complexity" | "assignee" | "schedule">>;
+    groupBy: "category" | "type" | "priority" | "complexity" | "status" | "assignee" | "schedule";
+    setGroupBy: Dispatch<SetStateAction<"category" | "type" | "priority" | "complexity" | "status" | "assignee" | "schedule">>;
     activeWorkspaceModule: WorkspaceModuleId;
     setActiveWorkspaceModule: Dispatch<SetStateAction<WorkspaceModuleId>>;
     emptyColumnMode: "show" | "collapse" | "hide";
@@ -553,6 +567,7 @@ export declare function useTaskforce({ config, initialTaskId, initialActivityEnt
     reorderWorkstreamTasks: (workstreamId: string, taskIds: string[]) => Promise<void>;
     handleEdit: (task: TaskItem, options?: {
         preserveReturnTrail?: boolean;
+        adoptAsBaseline?: boolean;
     }) => void;
     handleDelete: (id: string, archive?: boolean, options?: {
         skipConfirm?: boolean;
@@ -573,7 +588,7 @@ export declare function useTaskforce({ config, initialTaskId, initialActivityEnt
     handlePermanentlyDeleteDeletedTask: (id: string) => Promise<boolean>;
     handleEmptyDeletedTasks: () => Promise<number | null>;
     handleUpdateTask: (id: string, updates: Partial<TaskItem>) => Promise<boolean | undefined>;
-    handleSetStatus: (task: TaskItem, status: import("../core/TaskDurableStatusMutationService").DurableTaskTargetStatus, updates?: Partial<TaskItem>) => Promise<void>;
+    handleSetStatus: (task: TaskItem, status: import("../core/TaskDurableStatusMutationService").DurableTaskTargetStatus, updates?: Partial<TaskItem>, expectedDetailRevisionOverride?: string | null) => Promise<void>;
     editingTaskId: string | null;
     loading: boolean;
     error: string;
@@ -639,6 +654,10 @@ export declare function useTaskforce({ config, initialTaskId, initialActivityEnt
     pushNotice: (message: string, tone?: UiNotice["tone"], ttlMs?: number, action?: {
         label: string;
         onAction: () => void;
+        primary?: boolean;
+        secondaryLabel?: string;
+        onSecondaryAction?: () => void;
+        dismissible?: boolean;
         ownerKey?: string;
     }) => void;
     clearNotice: () => void;
@@ -735,8 +754,13 @@ export declare function useTaskforce({ config, initialTaskId, initialActivityEnt
         manualComplexityEnabled: boolean;
         checklistDropdownEnabled: boolean;
         showTaskCardStatusLabel: boolean;
+        showTaskCardDescription: boolean;
+        showTaskCardAttachments: boolean;
+        showTaskCardChecklistProgress: boolean;
+        showTaskCardLatestActivity: boolean;
+        tintTaskCardActivityBackground: boolean;
         pathSaved: boolean;
-        initialSection: "mcp" | "categories" | "types" | "priorities" | "general" | "agents" | "taxonomy" | "initiatives" | "documents" | "appearance-application" | "appearance-task-cards" | "appearance-task-forms" | "integrations" | null;
+        initialSection: "mcp" | "categories" | "types" | "priorities" | "general" | "documents" | "taxonomy" | "agents" | "initiatives" | "appearance-application" | "appearance-task-cards" | "appearance-task-forms" | "integrations" | null;
         setupState: any;
         buildInfo: any;
         onSaveSetupMode: (...args: any[]) => any;
@@ -744,15 +768,21 @@ export declare function useTaskforce({ config, initialTaskId, initialActivityEnt
         onThemeChange: (value: any) => void;
         onSaveTheme: (...args: any[]) => any;
         onSaveGlobalTheme: (...args: any[]) => any;
+        onUseGlobalThemeDefault: (...args: any[]) => any;
         onKeyShortcutChange: (value: string) => void;
         onJsonBackupEnabledChange: (...args: any[]) => any;
         onSaveGlobalJsonBackupEnabled: (...args: any[]) => any;
+        onUseGlobalJsonBackupDefault: (...args: any[]) => any;
         onSaveGlobalWeekStartsOn: (...args: any[]) => any;
         onSaveLocale: (...args: any[]) => any;
         onManualComplexityEnabledChange: (...args: any[]) => any;
         onChecklistDropdownEnabledChange: (...args: any[]) => any;
         onShowTaskCardStatusLabelChange: (...args: any[]) => any;
-        onResetProjectToGlobal: (...args: any[]) => any;
+        onShowTaskCardDescriptionChange: (...args: any[]) => any;
+        onShowTaskCardAttachmentsChange: (...args: any[]) => any;
+        onShowTaskCardChecklistProgressChange: (...args: any[]) => any;
+        onShowTaskCardLatestActivityChange: (...args: any[]) => any;
+        onTintTaskCardActivityBackgroundChange: (...args: any[]) => any;
         onSaveSettings: (...args: any[]) => any;
         initiativeTemplates: any[];
         onRefreshInitiativeTemplates: (...args: any[]) => any;
@@ -796,7 +826,7 @@ export declare function useTaskforce({ config, initialTaskId, initialActivityEnt
         cloudAuthBaseUrl: string | undefined;
         cloudMcpBaseUrl: string | undefined;
         workspaceSwitchingEnabled: boolean;
-        currentWorkspaceRole: "member" | "owner" | "admin" | "read-only";
+        currentWorkspaceRole: "owner" | "member" | "admin" | "read-only";
         currentWorkspaceName: string;
         onDeleteWorkspace: (...args: any[]) => any;
         onMcpHostRootChange: (value: string) => void;