@taskforcehq/taskforce 0.3.327 → 0.3.329

package/dist/hooks/useFilterSort.js

@@ -29,8 +29,9 @@ import { normalizeTaskSearchQuery, taskMatchesSearch } from '../utils/taskSearch
 import { compareTasksBySortKey } from '../utils/taxonomySorting.js';
 import { getFilterVisibleTaxonomyOptions } from '../utils/taxonomyFilterOptions.js';
 import { getVisibleTaxonomiesForTasks } from '../utils/taxonomyLifecycle.js';
+import { useCloudTaskSearch } from './tasks/useCloudTaskSearch';
 // === SECTION: Filter State ===
-export function useFilterSort({ tasks, archivedTasks, activeCategories, activeTypes, priorities, taxonomies, configLoaded, referenceDataLoaded, assigneeOptionsLoaded, assigneeOptions }) {
+export function useFilterSort({ tasks, archivedTasks, activeCategories, activeTypes, priorities, taxonomies, configLoaded, referenceDataLoaded, assigneeOptionsLoaded, assigneeOptions, runtimeMode = 'local', workspaceId = '', cloudTaskSearchEnabled = false, cloudTaskSearchScope = 'active', }) {
     const relationshipTasks = useMemo(() => [...tasks, ...archivedTasks], [archivedTasks, tasks]);
     const resolvedAssigneeOptions = useMemo(() => normalizeAssigneeOptions(assigneeOptions), [assigneeOptions]);
     const filterableTaxonomies = useMemo(() => getVisibleTaxonomiesForTasks(taxonomies, relationshipTasks)
@@ -42,6 +43,13 @@ export function useFilterSort({ tasks, archivedTasks, activeCategories, activeTy
     const filterableTaxonomyById = useMemo(() => new Map(filterableTaxonomies.map((taxonomy) => [taxonomy.id, taxonomy])), [filterableTaxonomies]);
     const assigneeFilterValues = useMemo(() => resolvedAssigneeOptions.map((opt) => opt.value), [resolvedAssigneeOptions]);
     const [searchQuery, setSearchQuery] = useState('');
+    const cloudSearchMatchIds = useCloudTaskSearch({
+        query: searchQuery,
+        runtimeMode,
+        workspaceId,
+        enabled: cloudTaskSearchEnabled,
+        scope: cloudTaskSearchScope,
+    });
     const [filterCategories, setFilterCategories] = useState([]);
     const [filterPriorities, setFilterPriorities] = useState([]);
     const [filterTypes, setFilterTypes] = useState([]);
@@ -229,7 +237,8 @@ export function useFilterSort({ tasks, archivedTasks, activeCategories, activeTy
         const isAllPrioritiesSelected = isAllFilterValuesSelected(Array.from(new Set(filterPriorities.map((value) => Number(value)).filter((value) => Number.isFinite(value)))), priorities.map((priority) => Number(priority.value)).filter((value) => Number.isFinite(value)));
         const isAllStatusesSelected = isAllFilterValuesSelected(filterStatus, STATUS_OPTIONS.map((status) => status.value));
         return tasks.filter(t => {
-            const matchSearch = taskMatchesSearch(t, normalizedSearchQuery, taskSearchContext);
+            const matchSearch = taskMatchesSearch(t, normalizedSearchQuery, taskSearchContext)
+                || (Boolean(normalizedSearchQuery.raw) && cloudSearchMatchIds.has(t.id));
             const matchCategory = !hasInitedFilters || isAllCategoriesSelected || filterCategories.includes(t.category);
             const matchPriority = !hasInitedFilters || isAllPrioritiesSelected || matchesPriorityFilter(t.priority, filterPriorities);
             const matchType = !hasInitedFilters || isAllTypesSelected || filterTypes.includes(t.type || DEFAULT_TYPE_VALUE);
@@ -253,7 +262,7 @@ export function useFilterSort({ tasks, archivedTasks, activeCategories, activeTy
             });
             return matchSearch && matchCategory && matchPriority && matchType && matchStatus && matchAssignee && matchTaxonomies;
         }).sort((a, b) => compareTasksBySortKey(a, b, sortBy, sortOrder, taxonomies));
-    }, [tasks, normalizedSearchQuery, taskSearchContext, filterCategories, filterPriorities, filterTypes, filterStatus, filterAssignees, filterAssigneesAllSelected, filterTaxonomies, sortBy, sortOrder, hasInitedFilters, filterableTaxonomies, filterableTaxonomyById, activeCategories, activeTypes, priorities, isAllFilterValuesSelected, taxonomies]);
+    }, [tasks, normalizedSearchQuery, taskSearchContext, cloudSearchMatchIds, filterCategories, filterPriorities, filterTypes, filterStatus, filterAssignees, filterAssigneesAllSelected, filterTaxonomies, sortBy, sortOrder, hasInitedFilters, filterableTaxonomies, filterableTaxonomyById, activeCategories, activeTypes, priorities, isAllFilterValuesSelected, taxonomies]);
     const searchAgnosticTasks = useMemo(() => {
         const isAllCategoriesSelected = isAllFilterValuesSelected(filterCategories, activeCategories.map((category) => category.value));
         const isAllTypesSelected = isAllFilterValuesSelected(filterTypes, activeTypes.map((type) => type.value));
@@ -288,7 +297,8 @@ export function useFilterSort({ tasks, archivedTasks, activeCategories, activeTy
         const isAllTypesSelected = isAllFilterValuesSelected(filterTypes, activeTypes.map((type) => type.value));
         const isAllPrioritiesSelected = isAllFilterValuesSelected(Array.from(new Set(filterPriorities.map((value) => Number(value)).filter((value) => Number.isFinite(value)))), priorities.map((priority) => Number(priority.value)).filter((value) => Number.isFinite(value)));
         return archivedTasks.filter(t => {
-            const matchSearch = taskMatchesSearch(t, normalizedSearchQuery, taskSearchContext);
+            const matchSearch = taskMatchesSearch(t, normalizedSearchQuery, taskSearchContext)
+                || (Boolean(normalizedSearchQuery.raw) && cloudSearchMatchIds.has(t.id));
             const matchCategory = !hasInitedFilters || isAllCategoriesSelected || filterCategories.includes(t.category);
             const matchPriority = !hasInitedFilters || isAllPrioritiesSelected || matchesPriorityFilter(t.priority, filterPriorities);
             const matchType = !hasInitedFilters || isAllTypesSelected || filterTypes.includes(t.type || DEFAULT_TYPE_VALUE);
@@ -310,7 +320,7 @@ export function useFilterSort({ tasks, archivedTasks, activeCategories, activeTy
             });
             return matchSearch && matchCategory && matchPriority && matchType && matchAssignee && matchTaxonomies;
         }).sort((a, b) => compareTasksBySortKey(a, b, sortBy, sortOrder, taxonomies));
-    }, [archivedTasks, normalizedSearchQuery, taskSearchContext, filterCategories, filterPriorities, filterTypes, filterAssignees, filterAssigneesAllSelected, filterTaxonomies, sortBy, sortOrder, hasInitedFilters, activeCategories, activeTypes, priorities, filterableTaxonomies, filterableTaxonomyById, isAllFilterValuesSelected, taxonomies]);
+    }, [archivedTasks, normalizedSearchQuery, taskSearchContext, cloudSearchMatchIds, filterCategories, filterPriorities, filterTypes, filterAssignees, filterAssigneesAllSelected, filterTaxonomies, sortBy, sortOrder, hasInitedFilters, activeCategories, activeTypes, priorities, filterableTaxonomies, filterableTaxonomyById, isAllFilterValuesSelected, taxonomies]);
     const groupedTasks = useMemo(() => {
         const groups = {};
         filteredTasks.forEach(task => {

package/dist/hooks/useTaskData.d.ts

@@ -12,10 +12,14 @@ interface UseTaskDataProps {
     handleUnauthorized: () => void;
     /** Only used to detect auth changes in the fetch dependency array */
     authRequiredForApi: boolean;
+    setError?: (value: string) => void;
+    setLoading?: (value: boolean) => void;
 }
-export declare function useTaskData({ tasks, archivedTasks, setTasks, setArchivedTasks, setLoadingTasks, getCurrentWorkspaceId, workspaceResetKey, shouldDeferProtectedApiCalls, shouldBlockProtectedApiCalls, handleUnauthorized, authRequiredForApi }: UseTaskDataProps): {
+export declare function useTaskData({ tasks, archivedTasks, setTasks, setArchivedTasks, setLoadingTasks, getCurrentWorkspaceId, workspaceResetKey, shouldDeferProtectedApiCalls, shouldBlockProtectedApiCalls, handleUnauthorized, authRequiredForApi, setError, setLoading }: UseTaskDataProps): {
     tasksRef: import("react").RefObject<TaskItem[]>;
     archivedTasksRef: import("react").RefObject<TaskItem[]>;
+    taskDetails: TaskItem[];
+    staleTaskDetailRevisions: Record<string, string>;
     recentlyChangedTaskIds: string[];
     markRecentlyChangedTasks: (taskIds: string[]) => void;
     fetchTasks: (isSilent?: boolean, options?: {
@@ -26,6 +30,11 @@ export declare function useTaskData({ tasks, archivedTasks, setTasks, setArchive
     fetchArchive: (isSilent?: boolean, options?: {
         ignoreAuthGuard?: boolean;
     }) => Promise<boolean>;
+    loadTaskDetail: (task: TaskItem, options?: {
+        shouldCommit?: () => boolean;
+        force?: boolean;
+    }) => Promise<TaskItem | null>;
+    cancelTaskDetailLoad: () => void;
     refreshTaskCollections: (options?: {
         isSilent?: boolean;
         ignoreAuthGuard?: boolean;

package/dist/hooks/useTaskData.js

@@ -23,9 +23,9 @@
  *   - getTaskRevisionKey(task) — stable revision string for change detection
  */
 import { useState, useEffect, useCallback, useRef } from 'react';
-import { getTaskContentRevision, mergeNormalizedTaskIntoCollections, normalizeTaskFromApi, reconcileTaskCollection } from '../utils/taskNormalization.js';
+import { getTaskContentRevision, mergeNormalizedTaskIntoCollections, normalizeTaskFromApi, reconcileTaskCollection, toTaskCollectionSummary } from '../utils/taskNormalization.js';
 import { resolveTaskReferenceId } from '../utils/taskReferences.js';
-export function useTaskData({ tasks, archivedTasks, setTasks, setArchivedTasks, setLoadingTasks, getCurrentWorkspaceId, workspaceResetKey, shouldDeferProtectedApiCalls, shouldBlockProtectedApiCalls, handleUnauthorized, authRequiredForApi }) {
+export function useTaskData({ tasks, archivedTasks, setTasks, setArchivedTasks, setLoadingTasks, getCurrentWorkspaceId, workspaceResetKey, shouldDeferProtectedApiCalls, shouldBlockProtectedApiCalls, handleUnauthorized, authRequiredForApi, setError, setLoading }) {
     // === SECTION: Revision Tracking ===
     const taskRevisionMapRef = useRef(new Map());
     const hasFetchedTasksRef = useRef(false);
@@ -34,6 +34,21 @@ export function useTaskData({ tasks, archivedTasks, setTasks, setArchivedTasks,
     const archivedTasksRef = useRef(archivedTasks);
     const tasksAbortRef = useRef(null);
     const archiveAbortRef = useRef(null);
+    const taskDetailAbortRef = useRef(null);
+    const taskDetailCacheRef = useRef(new Map());
+    const [taskDetails, setTaskDetails] = useState([]);
+    const [staleTaskDetailRevisions, setStaleTaskDetailRevisions] = useState({});
+    const getTaskSummaryRevision = useCallback((task) => (String(task.detailRevision || JSON.stringify([
+        task.updatedAt || task.createdAt || '',
+        task.commentCount || 0,
+        task.checklistCount || 0,
+        task.completedChecklistCount || 0,
+        task.attachmentCount || 0,
+        task.relationshipCount || 0,
+    ]))), []);
+    const publishTaskDetailCache = useCallback(() => {
+        setTaskDetails(Array.from(taskDetailCacheRef.current.values(), (entry) => entry.detail));
+    }, []);
     useEffect(() => {
         tasksRef.current = tasks;
     }, [tasks]);
@@ -87,12 +102,68 @@ export function useTaskData({ tasks, archivedTasks, setTasks, setArchivedTasks,
         tasksAbortRef.current = null;
         archiveAbortRef.current?.abort('workspace-reset');
         archiveAbortRef.current = null;
+        const hadPendingTaskDetail = taskDetailAbortRef.current !== null;
+        taskDetailAbortRef.current?.abort('workspace-reset');
+        taskDetailAbortRef.current = null;
+        if (hadPendingTaskDetail)
+            setLoading?.(false);
+        taskDetailCacheRef.current = new Map();
+        setTaskDetails([]);
+        setStaleTaskDetailRevisions({});
         if (typeof window !== 'undefined') {
             highlightTimersRef.current.forEach((timerId) => window.clearTimeout(timerId));
             highlightTimersRef.current.clear();
         }
         setRecentlyChangedTaskIds([]);
-    }, [workspaceResetKey]);
+    }, [setLoading, workspaceResetKey]);
+    useEffect(() => () => {
+        taskDetailAbortRef.current?.abort('unmount');
+    }, []);
+    const reconcileTaskDetailCache = useCallback((summaries, archived) => {
+        const summaryById = new Map(summaries.map((task) => [task.id, task]));
+        let changed = false;
+        const next = new Map(taskDetailCacheRef.current);
+        const nextStaleRevisions = {};
+        const reconciledTaskIds = new Set();
+        for (const [taskId, cached] of next) {
+            const summary = summaryById.get(taskId);
+            const belongsToCollection = Boolean(cached.detail.isArchived) === archived;
+            if (belongsToCollection)
+                reconciledTaskIds.add(taskId);
+            if (!summary && belongsToCollection) {
+                next.delete(taskId);
+                changed = true;
+                continue;
+            }
+            if (summary) {
+                const summaryRevision = getTaskSummaryRevision(summary);
+                if (summaryRevision !== cached.summaryRevision) {
+                    nextStaleRevisions[taskId] = summaryRevision;
+                }
+            }
+        }
+        setStaleTaskDetailRevisions((current) => {
+            const retained = Object.fromEntries(Object.entries(current).filter(([taskId]) => (!reconciledTaskIds.has(taskId))));
+            const combined = { ...retained, ...nextStaleRevisions };
+            const currentEntries = Object.entries(current);
+            const combinedEntries = Object.entries(combined);
+            return currentEntries.length === combinedEntries.length
+                && currentEntries.every(([taskId, revision]) => combined[taskId] === revision)
+                ? current
+                : combined;
+        });
+        if (changed) {
+            taskDetailCacheRef.current = next;
+            publishTaskDetailCache();
+        }
+    }, [getTaskSummaryRevision, publishTaskDetailCache]);
+    const cancelTaskDetailLoad = useCallback(() => {
+        const hadPendingTaskDetail = taskDetailAbortRef.current !== null;
+        taskDetailAbortRef.current?.abort('navigation');
+        taskDetailAbortRef.current = null;
+        if (hadPendingTaskDetail)
+            setLoading?.(false);
+    }, [setLoading]);
     // === SECTION: Fetch Functions ===
     const fetchTasks = useCallback(async (isSilent = false, options) => {
         const ignoreAuthGuard = options?.ignoreAuthGuard === true;
@@ -126,6 +197,7 @@ export function useTaskData({ tasks, archivedTasks, setTasks, setArchivedTasks,
                 if (liveWorkspaceId !== requestWorkspaceId) {
                     return;
                 }
+                reconcileTaskDetailCache(sanitized, false);
                 const nextRevisionMap = new Map();
                 const changedTaskIds = [];
                 const highlightChangedTaskIds = options?.highlightChangedTaskIds === undefined
@@ -178,7 +250,8 @@ export function useTaskData({ tasks, archivedTasks, setTasks, setArchivedTasks,
         setLoadingTasks,
         authRequiredForApi,
         shouldDeferProtectedApiCalls,
-        shouldBlockProtectedApiCalls
+        shouldBlockProtectedApiCalls,
+        reconcileTaskDetailCache
     ]);
     const fetchArchive = useCallback(async (isSilent = false, options) => {
         const ignoreAuthGuard = options?.ignoreAuthGuard === true;
@@ -202,6 +275,7 @@ export function useTaskData({ tasks, archivedTasks, setTasks, setArchivedTasks,
                     ...normalizeTaskFromApi(t),
                     isArchived: true
                 }));
+                reconcileTaskDetailCache(sanitized, true);
                 const previousArchivedTasks = archivedTasksRef.current;
                 const reconciledArchivedTasks = reconcileTaskCollection(previousArchivedTasks, sanitized);
                 archivedTasksRef.current = reconciledArchivedTasks;
@@ -225,7 +299,109 @@ export function useTaskData({ tasks, archivedTasks, setTasks, setArchivedTasks,
                     setLoadingTasks(false);
             }
         }
-    }, [getCurrentWorkspaceId, isExpectedAbortFailure, setArchivedTasks, setLoadingTasks, shouldDeferProtectedApiCalls, shouldBlockProtectedApiCalls]);
+    }, [getCurrentWorkspaceId, isExpectedAbortFailure, reconcileTaskDetailCache, setArchivedTasks, setLoadingTasks, shouldDeferProtectedApiCalls, shouldBlockProtectedApiCalls]);
+    const loadTaskDetail = useCallback(async (task, options) => {
+        const force = options?.force === true;
+        if (!force && !task.isSummary) {
+            const summary = toTaskCollectionSummary(task);
+            taskDetailCacheRef.current.set(task.id, { detail: task, summaryRevision: getTaskSummaryRevision(summary) });
+            setStaleTaskDetailRevisions((current) => {
+                if (!Object.prototype.hasOwnProperty.call(current, task.id))
+                    return current;
+                const next = { ...current };
+                delete next[task.id];
+                return next;
+            });
+            publishTaskDetailCache();
+            return task;
+        }
+        const cached = taskDetailCacheRef.current.get(task.id);
+        let requestedSummary = task;
+        let summaryRevision = getTaskSummaryRevision(requestedSummary);
+        if (!force && cached && cached.summaryRevision === summaryRevision)
+            return cached.detail;
+        const requestWorkspaceId = String(getCurrentWorkspaceId() || '').trim();
+        taskDetailAbortRef.current?.abort('superseded');
+        const abortController = new AbortController();
+        taskDetailAbortRef.current = abortController;
+        setLoading?.(true);
+        setError?.('');
+        try {
+            for (let attempt = 0; attempt < 2; attempt += 1) {
+                const response = await fetch(`/api/taskforce/task/${encodeURIComponent(requestedSummary.id)}`, {
+                    signal: abortController.signal,
+                });
+                if (response.status === 401) {
+                    handleUnauthorized();
+                    return null;
+                }
+                if (response.status === 404) {
+                    setError?.('Task not found. It may have moved or been deleted.');
+                    return null;
+                }
+                if (!response.ok) {
+                    setError?.('Unable to load task details.');
+                    return null;
+                }
+                const normalizedDetail = normalizeTaskFromApi(await response.json());
+                const liveWorkspaceId = String(getCurrentWorkspaceId() || '').trim();
+                if (abortController.signal.aborted || liveWorkspaceId !== requestWorkspaceId)
+                    return null;
+                const currentSummary = [...tasksRef.current, ...archivedTasksRef.current]
+                    .find((candidate) => candidate.id === requestedSummary.id);
+                if (!currentSummary) {
+                    setError?.('Task not found. It may have moved or been deleted.');
+                    return null;
+                }
+                const currentRevision = getTaskSummaryRevision(currentSummary);
+                if (currentRevision !== summaryRevision) {
+                    if (attempt === 0 && currentSummary) {
+                        requestedSummary = currentSummary;
+                        summaryRevision = currentRevision;
+                        continue;
+                    }
+                    setError?.('Task details changed while loading. Please open the task again.');
+                    return null;
+                }
+                if (requestedSummary.updatedAt
+                    && normalizedDetail.updatedAt
+                    && Date.parse(normalizedDetail.updatedAt) < Date.parse(requestedSummary.updatedAt)) {
+                    setError?.('Task details changed while loading. Please open the task again.');
+                    return null;
+                }
+                const detail = {
+                    ...normalizedDetail,
+                    detailRevision: normalizedDetail.detailRevision || summaryRevision,
+                };
+                if (options?.shouldCommit && !options.shouldCommit())
+                    return null;
+                taskDetailCacheRef.current.set(detail.id, { detail, summaryRevision });
+                setStaleTaskDetailRevisions((current) => {
+                    if (!Object.prototype.hasOwnProperty.call(current, detail.id))
+                        return current;
+                    const next = { ...current };
+                    delete next[detail.id];
+                    return next;
+                });
+                publishTaskDetailCache();
+                return detail;
+            }
+            return null;
+        }
+        catch (error) {
+            if (isExpectedAbortFailure(error, abortController.signal))
+                return null;
+            console.error('[Taskforce] Failed to fetch task detail:', error);
+            setError?.('Unable to load task details.');
+            return null;
+        }
+        finally {
+            if (taskDetailAbortRef.current === abortController) {
+                taskDetailAbortRef.current = null;
+                setLoading?.(false);
+            }
+        }
+    }, [getCurrentWorkspaceId, getTaskSummaryRevision, handleUnauthorized, isExpectedAbortFailure, publishTaskDetailCache, setError, setLoading]);
     const refreshTaskCollections = useCallback(async (options) => {
         const isSilent = options?.isSilent !== false;
         const ignoreAuthGuard = options?.ignoreAuthGuard === true;
@@ -253,7 +429,36 @@ export function useTaskData({ tasks, archivedTasks, setTasks, setArchivedTasks,
     }, [refreshTaskCollections]);
     // === SECTION: Merge Helper ===
     const mergeTaskFromServer = useCallback((task) => {
-        const merged = mergeNormalizedTaskIntoCollections(task, tasksRef.current, archivedTasksRef.current);
+        const normalized = normalizeTaskFromApi(task);
+        const existingSummary = [...tasksRef.current, ...archivedTasksRef.current]
+            .find((candidate) => candidate.id === normalized.id);
+        const collectionSummary = normalized.isSummary
+            ? normalized
+            : toTaskCollectionSummary({
+                ...normalized,
+                detailRevision: undefined,
+                commentCount: normalized.commentCount ?? (normalized.comments ? undefined : existingSummary?.commentCount),
+                checklistCount: normalized.checklistCount ?? (normalized.checklistItems ? undefined : existingSummary?.checklistCount),
+                completedChecklistCount: normalized.completedChecklistCount
+                    ?? (normalized.checklistItems ? undefined : existingSummary?.completedChecklistCount),
+                attachmentCount: normalized.attachmentCount ?? (normalized.attachments ? undefined : existingSummary?.attachmentCount),
+                relationshipCount: normalized.relationshipCount ?? existingSummary?.relationshipCount ?? 0,
+            });
+        if (!normalized.isSummary) {
+            taskDetailCacheRef.current.set(normalized.id, {
+                detail: normalized,
+                summaryRevision: getTaskSummaryRevision(collectionSummary),
+            });
+            publishTaskDetailCache();
+            setStaleTaskDetailRevisions((current) => {
+                if (!Object.prototype.hasOwnProperty.call(current, normalized.id))
+                    return current;
+                const next = { ...current };
+                delete next[normalized.id];
+                return next;
+            });
+        }
+        const merged = mergeNormalizedTaskIntoCollections(collectionSummary, tasksRef.current, archivedTasksRef.current);
         const tasksChanged = merged.tasks !== tasksRef.current;
         const archivedTasksChanged = merged.archivedTasks !== archivedTasksRef.current;
         tasksRef.current = merged.tasks;
@@ -262,17 +467,21 @@ export function useTaskData({ tasks, archivedTasks, setTasks, setArchivedTasks,
             setTasks(merged.tasks);
         if (archivedTasksChanged)
             setArchivedTasks(merged.archivedTasks);
-    }, [setTasks, setArchivedTasks]);
+    }, [getTaskSummaryRevision, publishTaskDetailCache, setTasks, setArchivedTasks]);
     return {
         // Stable refs (for use inside closures)
         tasksRef,
         archivedTasksRef,
+        taskDetails,
+        staleTaskDetailRevisions,
         // Recently changed
         recentlyChangedTaskIds,
         markRecentlyChangedTasks,
         // Fetch functions
         fetchTasks,
         fetchArchive,
+        loadTaskDetail,
+        cancelTaskDetailLoad,
         refreshTaskCollections,
         refreshTaskCollectionsFromInvalidation,
         // Helpers

package/dist/hooks/useTaskMutations.d.ts

@@ -13,6 +13,7 @@ export interface UseTaskMutationsProps {
     tasks: TaskItem[];
     archivedTasks: TaskItem[];
     editingTaskId: string | null;
+    editingTaskDetailRevision?: string | null;
     setTasks: React.Dispatch<React.SetStateAction<TaskItem[]>>;
     setArchivedTasks: React.Dispatch<React.SetStateAction<TaskItem[]>>;
     setDeletedTasks: React.Dispatch<React.SetStateAction<DeletedTaskRecord[]>>;
@@ -44,6 +45,13 @@ export interface UseTaskMutationsProps {
     durableTaskHttpRootActivationEnabled?: boolean;
     workspaceId?: string;
     taskHttpMutationClient?: ReturnType<typeof createCloudTaskHttpMutationClient>;
+    onTaskRevisionConflict?: (taskId: string, currentDetailRevision: string | null) => TaskRevisionConflictResolution | void | Promise<TaskRevisionConflictResolution | void>;
+    onTaskMutationAccepted?: (task: TaskItem) => void;
+}
+export interface TaskRevisionConflictResolution {
+    handled: boolean;
+    retryDetailRevision?: string;
+    retryPatch?: Partial<TaskItem>;
 }
 export interface DeletedTaskRestoreFailure {
     deletedRecordId: string;
@@ -58,13 +66,13 @@ export interface DeletedTaskRestoreBatchResult {
     succeeded: DeletedTaskRecord[];
     failed: DeletedTaskRestoreFailure[];
 }
-export declare 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, durableTaskStatusActivationEnabled, durableTaskDeleteActivationEnabled, durableTaskHttpRootActivationEnabled, workspaceId, taskHttpMutationClient, }: UseTaskMutationsProps): {
+export declare function useTaskMutations({ tasks, archivedTasks, editingTaskId, editingTaskDetailRevision, 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, durableTaskStatusActivationEnabled, durableTaskDeleteActivationEnabled, durableTaskHttpRootActivationEnabled, workspaceId, taskHttpMutationClient, onTaskRevisionConflict, onTaskMutationAccepted, }: UseTaskMutationsProps): {
     copiedId: string | null;
     handleDelete: (id: string, archive?: boolean, options?: {
         skipConfirm?: boolean;
     }) => Promise<boolean>;
     handleUpdateTask: (id: string, updates: Partial<TaskItem>) => Promise<boolean | undefined>;
-    handleSetStatus: (task: TaskItem, status: DurableTaskTargetStatus, updates?: Partial<TaskItem>) => Promise<void>;
+    handleSetStatus: (task: TaskItem, status: DurableTaskTargetStatus, updates?: Partial<TaskItem>, expectedDetailRevisionOverride?: string | null) => Promise<void>;
     handleToggleComplete: (task: TaskItem) => Promise<void>;
     handleToggleCancel: (task: TaskItem) => Promise<void>;
     handleToggleInProgress: (task: TaskItem) => Promise<void>;