@taskforcehq/taskforce 0.3.326 → 0.3.328

package/dist/hooks/useTaskMutations.js

@@ -1,11 +1,93 @@
 import { useState, useCallback, useEffect, useRef } from 'react';
 import { normalizeTaskFromApi } from '../utils/taskNormalization.js';
-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, }) {
+import { DURABLE_TASK_METADATA_FIELDS, selectDurableTaskMetadataPatch, } from '../core/TaskDurableSyncMutationService.js';
+import { createCloudTaskHttpMutationClient, fetchTaskHttpMutation, isConclusiveTaskHttpResponse, } from './tasks/taskHttpMutation.js';
+import { TASKFORCE_TASKS_MUTATED_EVENT, } from '../utils/taskEvents.js';
+import { canonicalWorkspaceSyncJson } from '../sync/v3/canonicalWorkspaceSyncJson.js';
+const DURABLE_TASK_METADATA_FIELD_NAMES = DURABLE_TASK_METADATA_FIELDS;
+const TASK_STATUS_CONTROL_FIELDS = new Set([
+    'status', 'assignee', 'canceledReason', 'completedAt',
+    'completed', 'inProgress', 'readyForReview', 'cancelled',
+]);
+function taskFieldValuesEqual(left, right) {
+    if (left === undefined || right === undefined)
+        return left === right;
+    return canonicalWorkspaceSyncJson(left) === canonicalWorkspaceSyncJson(right);
+}
+function rollbackTargetTaskPatch(currentTasks, previousTask, taskId, patch) {
+    if (!previousTask)
+        return currentTasks;
+    return currentTasks.map((task) => {
+        if (task.id !== taskId)
+            return task;
+        const restored = { ...task };
+        for (const key of Object.keys(patch)) {
+            if (Object.prototype.hasOwnProperty.call(previousTask, key)) {
+                restored[key] = previousTask[key];
+            }
+            else {
+                delete restored[key];
+            }
+        }
+        return restored;
+    });
+}
+function taskHttpObservedPrecondition(task, taskId) {
+    return {
+        taskId,
+        updatedAt: task?.updatedAt ?? 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, }) {
+    const authoritativeTaskSnapshotsRef = useRef(new Map());
+    useEffect(() => {
+        if (typeof window === 'undefined')
+            return;
+        const handleAuthoritativeTask = (event) => {
+            const detail = event.detail;
+            const authoritativeTask = detail?.authoritativeTask;
+            const eventWorkspaceId = String(detail?.workspaceId || '').trim() || 'default';
+            if (!authoritativeTask || eventWorkspaceId !== workspaceId)
+                return;
+            authoritativeTaskSnapshotsRef.current.set(authoritativeTask.id, authoritativeTask);
+            mergeTaskFromServer(authoritativeTask);
+        };
+        window.addEventListener(TASKFORCE_TASKS_MUTATED_EVENT, handleAuthoritativeTask);
+        return () => window.removeEventListener(TASKFORCE_TASKS_MUTATED_EVENT, handleAuthoritativeTask);
+    }, [mergeTaskFromServer, workspaceId]);
     // Copy ID state + timer ref
     const [copiedId, setCopiedId] = useState(null);
     const copiedIdTimerRef = useRef(null);
     const workspaceSyncTimerRef = useRef(null);
     const workspaceSyncTargetAtRef = useRef(null);
+    const taskHttpMutationClientRef = useRef(null);
+    const fetchCloudTaskMutation = useCallback(async (url, requestInit, body, observedPrecondition, validateSuccess) => {
+        const carriesDurableNestedTaskState = ['checklistItems', 'attachments', 'comments']
+            .some((key) => Object.prototype.hasOwnProperty.call(body, key));
+        if (!durableTaskHttpRootActivationEnabled && !carriesDurableNestedTaskState) {
+            return fetch(url, requestInit);
+        }
+        if (!taskHttpMutationClientRef.current) {
+            taskHttpMutationClientRef.current = taskHttpMutationClient || createCloudTaskHttpMutationClient();
+        }
+        const attempt = await taskHttpMutationClientRef.current.prepareUpdate(workspaceId, url, body, observedPrecondition);
+        const response = await fetchTaskHttpMutation(url, requestInit, attempt.operationId);
+        if (response.ok) {
+            const payload = await response.clone().json().catch(() => null);
+            if (!validateSuccess(payload)) {
+                throw new Error('Durable cloud task mutation returned an invalid authoritative response.');
+            }
+            await taskHttpMutationClientRef.current.confirmUpdate(attempt.fingerprint, attempt.operationId);
+        }
+        else if (await isConclusiveTaskHttpResponse(response)) {
+            await taskHttpMutationClientRef.current.confirmUpdate(attempt.fingerprint, attempt.operationId);
+        }
+        return response;
+    }, [durableTaskHttpRootActivationEnabled, taskHttpMutationClient, workspaceId]);
+    const fetchCloudTaskRootPatch = useCallback((url, requestInit, body, expectedTaskId, observedPrecondition) => fetchCloudTaskMutation(url, requestInit, body, observedPrecondition, (payload) => (!!payload && typeof payload === 'object'
+        && String(payload.id || '') === expectedTaskId)), [fetchCloudTaskMutation]);
     useEffect(() => () => {
         if (typeof window === 'undefined')
             return;
@@ -62,15 +144,53 @@ export function useTaskMutations({ tasks, archivedTasks, editingTaskId, setTasks
             return false;
         const isArchivedTask = archive || archivedTasks.some((task) => task.id === id);
         try {
-            const res = await fetch(`/api/taskforce/task/${id}`, { method: 'DELETE' });
-            if (!res.ok) {
-                const data = await res.json().catch(() => ({}));
-                const message = data.error || 'Failed to delete task.';
-                setError(message);
-                pushNotice(message, 'error');
-                return false;
+            let durableDeletedRecord = null;
+            if (durableTaskDeleteActivationEnabled) {
+                const durableResult = await mutateTaskDelete?.(id);
+                if (!durableResult) {
+                    const message = 'Task was not deleted because durable capture was unavailable.';
+                    setError(message);
+                    pushNotice(message, 'error');
+                    return false;
+                }
+                if (durableResult.state !== 'disabled') {
+                    if (durableResult.state === 'rejected'
+                        || durableResult.state === 'failed'
+                        || durableResult.state === 'ambiguous') {
+                        const message = durableResult.state === 'ambiguous'
+                            ? 'Task delete confirmation was interrupted. Retry the same delete to confirm it safely.'
+                            : `Task was not deleted because durable capture rejected it${durableResult.errorCode ? ` (${durableResult.errorCode})` : ''}.`;
+                        setError(message);
+                        pushNotice(message, 'error');
+                        return false;
+                    }
+                    durableDeletedRecord = durableResult.deleted || null;
+                    if (!durableDeletedRecord) {
+                        const message = 'Task delete was captured, but its Trash record was unavailable.';
+                        setError(message);
+                        pushNotice(message, 'error');
+                        return false;
+                    }
+                }
+            }
+            let data = durableDeletedRecord ? { deleted: durableDeletedRecord } : {};
+            if (!durableDeletedRecord) {
+                const url = `/api/taskforce/task/${id}`;
+                const observed = tasks.find((task) => task.id === id) || archivedTasks.find((task) => task.id === id);
+                const res = await fetchCloudTaskMutation(url, { method: 'DELETE' }, {}, taskHttpObservedPrecondition(observed, id), (payload) => (!!payload && typeof payload === 'object'
+                    && payload.success === true
+                    && !!payload.deleted
+                    && typeof payload.deleted === 'object'
+                    && String((payload.deleted).taskId || '') === id));
+                if (!res.ok) {
+                    const responseData = await res.json().catch(() => ({}));
+                    const message = responseData.error || 'Failed to delete task.';
+                    setError(message);
+                    pushNotice(message, 'error');
+                    return false;
+                }
+                data = await res.json().catch(() => ({}));
             }
-            const data = await res.json().catch(() => ({}));
             const deletedRecord = data?.deleted && typeof data.deleted === 'object' && data.deleted.taskSnapshot
                 ? {
                     ...data.deleted,
@@ -100,7 +220,7 @@ export function useTaskMutations({ tasks, archivedTasks, editingTaskId, setTasks
                 workspaceDeletedTaskWatermarksRef.current.set(id, new Date().toISOString());
             }
             workspaceDeletedTaskIdsRef.current.add(id);
-            if (cloudAuthConfigured && runtimeMode === 'local' && isAuthenticated && workspaceCloudSyncEnabled) {
+            if (!durableDeletedRecord && cloudAuthConfigured && runtimeMode === 'local' && isAuthenticated && workspaceCloudSyncEnabled) {
                 const signature = buildWorkspaceSyncSignature();
                 workspacePendingSignatureRef.current = signature;
                 void pushWorkspaceChangesToCloud(signature);
@@ -120,14 +240,59 @@ export function useTaskMutations({ tasks, archivedTasks, editingTaskId, setTasks
             return false;
         }
     };
-    const handleRestoreDeletedTask = useCallback(async (id) => {
+    const handleRestoreDeletedTask = useCallback(async (id, expectedTaskId, options = {}) => {
         try {
-            const res = await requestDeletedEndpoint(`/${id}/restore`, { method: 'POST' });
+            const url = `/api/taskforce/deleted/${id}/restore`;
+            const observedTaskId = String(expectedTaskId || '').trim();
+            if (durableTaskDeleteActivationEnabled) {
+                if (!observedTaskId || !mutateTaskRestore) {
+                    throw new Error('Durable local task restore requires the expected task identity and capture client.');
+                }
+                const durableResult = await mutateTaskRestore(id, observedTaskId, options.restoreDestination || 'previous');
+                if (!durableResult || durableResult.state === 'failed' || durableResult.state === 'ambiguous'
+                    || durableResult.state === 'rejected' || durableResult.state === 'disabled') {
+                    const message = 'Failed to capture task restore durably.';
+                    setError(message);
+                    if (!options.silent)
+                        pushNotice(message, 'error');
+                    return null;
+                }
+                const restoredTask = durableResult.task;
+                if (!restoredTask || restoredTask.id !== observedTaskId) {
+                    throw new Error('Durable local task restore did not return the restored task.');
+                }
+                mergeTaskFromServer(restoredTask);
+                setDeletedTasks((prev) => prev.filter((entry) => entry.id !== id && entry.taskId !== observedTaskId));
+                workspaceDeletedTaskIdsRef.current.delete(id);
+                workspaceDeletedTaskIdsRef.current.delete(observedTaskId);
+                workspaceDeletedTaskWatermarksRef.current.delete(id);
+                workspaceDeletedTaskWatermarksRef.current.delete(observedTaskId);
+                setError('');
+                if (!options.silent) {
+                    pushNotice(durableResult.state === 'accepted' ? 'Task restored from Trash.' : 'Task restored locally; cloud sync is pending.', 'info');
+                }
+                return normalizeTaskFromApi(restoredTask);
+            }
+            if (durableTaskHttpRootActivationEnabled && !observedTaskId) {
+                throw new Error('Durable cloud task restore requires the expected task identity.');
+            }
+            const deletedAt = workspaceDeletedTaskWatermarksRef.current.get(observedTaskId)
+                || workspaceDeletedTaskWatermarksRef.current.get(id)
+                || null;
+            const res = durableTaskHttpRootActivationEnabled
+                ? await fetchCloudTaskMutation(url, { method: 'POST' }, {}, { taskId: observedTaskId, updatedAt: deletedAt, status: 'deleted', isArchived: false }, (payload) => {
+                    if (!payload || typeof payload !== 'object')
+                        return false;
+                    const restoredId = String(payload.id || '').trim();
+                    return restoredId === observedTaskId;
+                })
+                : await requestDeletedEndpoint(`/${id}/restore`, { method: 'POST' });
             if (!res.ok) {
                 const data = await res.json().catch(() => ({}));
                 const message = data.error || 'Failed to restore deleted task.';
                 setError(message);
-                pushNotice(message, 'error');
+                if (!options.silent)
+                    pushNotice(message, 'error');
                 return null;
             }
             const restoredTask = await res.json().catch(() => null);
@@ -137,8 +302,10 @@ export function useTaskMutations({ tasks, archivedTasks, editingTaskId, setTasks
             else {
                 await fetchTasks(true);
             }
-            setDeletedTasks((prev) => prev.filter((entry) => entry.id !== id && entry.taskId !== id));
             const restoredTaskId = String(restoredTask?.id || '').trim();
+            setDeletedTasks((prev) => prev.filter((entry) => (entry.id !== id
+                && entry.taskId !== observedTaskId
+                && entry.taskId !== restoredTaskId)));
             workspaceDeletedTaskIdsRef.current.delete(id);
             workspaceDeletedTaskWatermarksRef.current.delete(id);
             if (restoredTaskId) {
@@ -147,18 +314,27 @@ export function useTaskMutations({ tasks, archivedTasks, editingTaskId, setTasks
             }
             queueWorkspaceSyncFromAuthoritativeTaskState();
             setError('');
-            pushNotice('Task restored from Trash.', 'info');
+            if (!options.silent) {
+                pushNotice(restoredTask?.isArchived === true
+                    ? 'Task restored to Archived.'
+                    : 'Task restored to Active.', 'info');
+            }
             return restoredTask ? normalizeTaskFromApi(restoredTask) : null;
         }
         catch (err) {
             console.error('Failed to restore deleted task:', err);
             setError('Failed to restore deleted task.');
-            pushNotice('Failed to restore deleted task.', 'error');
+            if (!options.silent)
+                pushNotice('Failed to restore deleted task.', 'error');
             return null;
         }
     }, [
+        durableTaskHttpRootActivationEnabled,
+        durableTaskDeleteActivationEnabled,
+        fetchCloudTaskMutation,
         fetchTasks,
         mergeTaskFromServer,
+        mutateTaskRestore,
         pushNotice,
         queueWorkspaceSyncFromAuthoritativeTaskState,
         requestDeletedEndpoint,
@@ -225,63 +401,127 @@ export function useTaskMutations({ tasks, archivedTasks, editingTaskId, setTasks
         setDeletedTasks,
         setError
     ]);
-    const handleUpdateTask = useCallback(async (id, updates) => {
+    const finishDurableTaskMutation = useCallback((result, taskId, optimisticPatch, previousTasks, previousArchivedTasks) => {
+        if (result.state === 'disabled')
+            return false;
+        if (result.state === 'rejected' || result.state === 'failed') {
+            const previousTask = previousTasks.find((task) => task.id === taskId)
+                || previousArchivedTasks.find((task) => task.id === taskId);
+            setTasks((current) => rollbackTargetTaskPatch(current, previousTask, taskId, optimisticPatch));
+            setArchivedTasks((current) => rollbackTargetTaskPatch(current, previousTask, taskId, optimisticPatch));
+            const message = result.state === 'failed'
+                ? 'Task was not saved because durable local preparation failed. Retry the edit.'
+                : result.retryable
+                    ? 'Task was not saved because durable capture is busy. Retry the edit shortly.'
+                    : `Task was not saved because durable capture rejected it${result.errorCode ? ` (${result.errorCode})` : ''}.`;
+            setError(message);
+            pushNotice(message, 'error');
+            return true;
+        }
+        if ('task' in result && result.task)
+            mergeTaskFromServer(result.task);
+        if (result.state === 'accepted') {
+            setError('');
+        }
+        else if (result.state === 'pending') {
+            setError('');
+            if (result.pendingReason !== 'queued') {
+                pushNotice(result.pendingReason === 'auth'
+                    ? 'Task saved locally. Sign in to finish cloud sync.'
+                    : result.pendingReason === 'sync-disabled'
+                        ? 'Task saved locally. Turn on sync to send it to cloud.'
+                        : 'Task saved locally. Cloud sync will retry automatically.', 'info');
+            }
+        }
+        else {
+            const message = result.state === 'blocked'
+                ? `Task saved locally, but cloud sync is blocked${result.errorCode ? ` (${result.errorCode})` : ''}.`
+                : 'Task save confirmation was interrupted. Retry the same edit to confirm it safely.';
+            setError(message);
+            pushNotice(message, 'error');
+        }
+        return true;
+    }, [mergeTaskFromServer, pushNotice, setArchivedTasks, setError, setTasks]);
+    const handleSetStatus = useCallback(async (task, status, updates = {}) => {
+        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)));
+        if (durableTaskStatusActivationEnabled && unsupportedFields.length > 0) {
+            const message = `Task status was not saved because the combined update contains unsupported fields: ${unsupportedFields.sort().join(', ')}.`;
+            setError(message);
+            pushNotice(message, 'error');
+            return;
+        }
+        const now = new Date().toISOString();
+        const optimisticPatch = {
+            ...updates,
+            status,
+            completedAt: status === 'done' || status === 'cancelled' ? (updates.completedAt || now) : null,
+            completed: status === 'done',
+            inProgress: status === 'in-progress',
+            readyForReview: status === 'review',
+            cancelled: status === 'cancelled',
+        };
         const previousTasks = tasks;
         const previousArchivedTasks = archivedTasks;
-        setTasks(prev => prev.map(t => t.id === id ? { ...t, ...updates } : t));
-        setArchivedTasks(prev => prev.map(t => t.id === id ? { ...t, ...updates } : t));
-        try {
-            const res = await fetch(`/api/taskforce/task/${id}`, {
-                method: 'PATCH',
-                headers: { 'Content-Type': 'application/json' },
-                body: JSON.stringify(updates),
-            });
-            if (!res.ok) {
-                const data = await res.json().catch(() => ({}));
-                const message = data.error || `Failed to update task ${id}.`;
+        setTasks((current) => current.map((item) => item.id === task.id ? { ...item, ...optimisticPatch } : item));
+        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,
+                });
+                if (durableResult && finishDurableTaskMutation(durableResult, task.id, optimisticPatch, previousTasks, previousArchivedTasks))
+                    return;
+                if (!durableResult && durableTaskStatusActivationEnabled) {
+                    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 message = 'Task status was not saved because durable capture was unavailable.';
+                    setError(message);
+                    pushNotice(message, 'error');
+                    return;
+                }
+            }
+            catch (error) {
+                console.error('Durable task status update failed before a conclusive result.', error);
+                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 message = 'Task save confirmation was interrupted. Retry the same edit to confirm it safely.';
                 setError(message);
                 pushNotice(message, 'error');
-                setTasks(previousTasks);
-                setArchivedTasks(previousArchivedTasks);
                 return;
             }
-            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('');
         }
-        catch (err) {
-            console.error("Failed to update task", err);
-            const message = `Failed to update task ${id}.`;
+        if (durableTaskMetadataActivationEnabled && containsDurableMetadata) {
+            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 message = 'Task was not saved because durable status capture is required for this combined metadata update.';
             setError(message);
             pushNotice(message, 'error');
-            setTasks(previousTasks);
-            setArchivedTasks(previousArchivedTasks);
+            return;
         }
-    }, [tasks, archivedTasks, pushNotice, mergeTaskFromServer, queueWorkspaceSyncFromAuthoritativeTaskState]);
-    const handleToggleComplete = async (task) => {
-        const newStatus = task.status === 'done' ? 'task' : 'done';
-        const completedAt = newStatus === 'done' ? new Date().toISOString() : undefined;
-        const optimisticUpdates = {
-            status: newStatus,
-            completedAt,
-            completed: newStatus === 'done',
-            inProgress: false,
-            readyForReview: false,
-            cancelled: false
-        };
-        const previousTasks = tasks;
-        const previousArchivedTasks = archivedTasks;
-        setTasks(prev => prev.map(t => t.id === task.id ? { ...t, ...optimisticUpdates } : t));
-        setArchivedTasks(prev => prev.map(t => t.id === task.id ? { ...t, ...optimisticUpdates } : t));
         try {
-            const res = await fetch(`/api/taskforce/task/${task.id}`, {
+            const legacyPatch = { ...updates, status, completedAt: optimisticPatch.completedAt };
+            const requestInit = {
                 method: 'PATCH',
                 headers: { 'Content-Type': 'application/json' },
-                body: JSON.stringify({ status: newStatus, completedAt }),
-            });
+                body: JSON.stringify(legacyPatch),
+            };
+            const res = await fetchCloudTaskRootPatch(`/api/taskforce/task/${task.id}`, requestInit, legacyPatch, task.id, taskHttpObservedPrecondition(task, task.id));
             if (!res.ok) {
                 const data = await res.json().catch(() => ({}));
                 const message = data.error || 'Failed to update task status.';
@@ -292,105 +532,273 @@ export function useTaskMutations({ tasks, archivedTasks, editingTaskId, setTasks
                 return;
             }
             const updatedTask = await res.json().catch(() => null);
-            if (updatedTask) {
+            if (updatedTask)
                 mergeTaskFromServer(updatedTask);
-                queueWorkspaceSyncFromAuthoritativeTaskState();
-            }
-            else {
+            else
                 await fetchTasks(true);
-                queueWorkspaceSyncFromAuthoritativeTaskState();
-            }
+            queueWorkspaceSyncFromAuthoritativeTaskState();
             setError('');
         }
-        catch (err) {
-            console.error("Failed to toggle complete", err);
+        catch (error) {
+            console.error('Failed to update task status.', error);
             setError('Failed to update task status.');
             pushNotice('Failed to update task status.', 'error');
             setTasks(previousTasks);
             setArchivedTasks(previousArchivedTasks);
         }
-    };
-    const handleToggleCancel = async (task) => {
-        const newStatus = task.status === 'cancelled' ? 'task' : 'cancelled';
-        try {
-            const res = await fetch(`/api/taskforce/task/${task.id}`, {
-                method: 'PATCH',
-                headers: { 'Content-Type': 'application/json' },
-                body: JSON.stringify({ status: newStatus }),
-            });
-            if (!res.ok) {
-                const data = await res.json().catch(() => ({}));
-                const message = data.error || 'Failed to update task status.';
+    }, [
+        archivedTasks,
+        durableTaskMetadataActivationEnabled,
+        durableTaskHttpRootActivationEnabled,
+        durableTaskStatusActivationEnabled,
+        fetchTasks,
+        fetchCloudTaskRootPatch,
+        finishDurableTaskMutation,
+        mergeTaskFromServer,
+        mutateTaskStatus,
+        pushNotice,
+        queueWorkspaceSyncFromAuthoritativeTaskState,
+        setArchivedTasks,
+        setError,
+        setTasks,
+        tasks,
+    ]);
+    const handleUpdateTask = useCallback(async (id, updates) => {
+        const saveSource = updates.saveSource;
+        updates = Object.fromEntries(Object.entries(updates).filter(([key]) => key !== 'saveSource'));
+        if (Object.keys(updates).length === 0)
+            return true;
+        const authoritativeTask = authoritativeTaskSnapshotsRef.current.get(id);
+        const collectionTask = tasks.find((task) => task.id === id)
+            || archivedTasks.find((task) => task.id === id);
+        const authoritativeUpdatedAt = Date.parse(String(authoritativeTask?.updatedAt || ''));
+        const collectionUpdatedAt = Date.parse(String(collectionTask?.updatedAt || ''));
+        const observedTask = authoritativeTask && (!collectionTask
+            || (Number.isFinite(authoritativeUpdatedAt)
+                && (!Number.isFinite(collectionUpdatedAt) || authoritativeUpdatedAt >= collectionUpdatedAt)))
+            ? authoritativeTask
+            : collectionTask;
+        if (collectionTask && observedTask === collectionTask && authoritativeTask) {
+            authoritativeTaskSnapshotsRef.current.delete(id);
+        }
+        if (observedTask) {
+            updates = Object.fromEntries(Object.entries(updates).filter(([key, value]) => (!taskFieldValuesEqual(observedTask[key], value))));
+            if (Object.keys(updates).length === 0)
+                return true;
+        }
+        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);
+                return;
+            }
+            if (durableTaskStatusActivationEnabled) {
+                const message = 'Task status was not saved because the current task could not be resolved safely.';
                 setError(message);
                 pushNotice(message, 'error');
-                await fetchTasks(true);
                 return;
             }
-            const updatedTask = await res.json().catch(() => null);
-            if (updatedTask) {
-                mergeTaskFromServer(updatedTask);
-                queueWorkspaceSyncFromAuthoritativeTaskState();
+        }
+        const previousTasks = tasks;
+        const previousArchivedTasks = archivedTasks;
+        setTasks(prev => prev.map(t => t.id === id ? { ...t, ...updates } : t));
+        setArchivedTasks(prev => prev.map(t => t.id === id ? { ...t, ...updates } : t));
+        const durableMetadataPatch = Object.fromEntries(Object.entries(updates).filter(([key]) => DURABLE_TASK_METADATA_FIELD_NAMES.has(key)));
+        let legacyCarrierPatch = Object.fromEntries(Object.entries(updates).filter(([key]) => !DURABLE_TASK_METADATA_FIELD_NAMES.has(key)));
+        const hasDurableMetadata = Object.keys(durableMetadataPatch).length > 0;
+        let hasLegacyCarriers = Object.keys(legacyCarrierPatch).length > 0;
+        let durableMetadataHandled = false;
+        if (hasDurableMetadata && mutateTaskMetadata) {
+            try {
+                const durableResult = saveSource
+                    ? await mutateTaskMetadata(id, durableMetadataPatch, { saveSource })
+                    : await mutateTaskMetadata(id, durableMetadataPatch);
+                if (durableResult && durableResult.state !== 'disabled') {
+                    if (durableResult.state === 'rejected' || durableResult.state === 'failed') {
+                        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 = durableResult.state === 'failed'
+                            ? 'Task was not saved because durable local preparation failed. Retry the edit.'
+                            : durableResult.retryable
+                                ? 'Task was not saved because durable capture is busy. Retry the edit shortly.'
+                                : `Task was not saved because durable capture rejected it${durableResult.errorCode ? ` (${durableResult.errorCode})` : ''}.`;
+                        setError(message);
+                        pushNotice(message, 'error');
+                        return false;
+                    }
+                    durableMetadataHandled = true;
+                    if ('task' in durableResult && durableResult.task)
+                        mergeTaskFromServer(durableResult.task);
+                    if (durableResult.state === 'accepted') {
+                        setError('');
+                    }
+                    else if (durableResult.state === 'pending') {
+                        setError('');
+                        if (durableResult.pendingReason !== 'queued') {
+                            pushNotice(durableResult.pendingReason === 'auth'
+                                ? 'Task saved locally. Sign in to finish cloud sync.'
+                                : durableResult.pendingReason === 'sync-disabled'
+                                    ? 'Task saved locally. Turn on sync to send it to cloud.'
+                                    : 'Task saved locally. Cloud sync will retry automatically.', 'info');
+                        }
+                    }
+                    else {
+                        const message = durableResult.state === 'blocked'
+                            ? `Task saved locally, but cloud sync is blocked${durableResult.errorCode ? ` (${durableResult.errorCode})` : ''}.`
+                            : 'Task save confirmation was interrupted. Retry the same edit to confirm it safely.';
+                        setError(message);
+                        pushNotice(message, 'error');
+                    }
+                    if (durableResult.state === 'ambiguous') {
+                        if (hasLegacyCarriers) {
+                            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));
+                        }
+                        return false;
+                    }
+                    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 {
-                await fetchTasks(true);
-                queueWorkspaceSyncFromAuthoritativeTaskState();
+            catch (error) {
+                console.error('Durable task metadata update failed before a conclusive result.', error);
+                if (hasLegacyCarriers) {
+                    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));
+                }
+                const message = 'Task save confirmation was interrupted. Retry the same edit to confirm it safely.';
+                setError(message);
+                pushNotice(message, 'error');
+                return false;
             }
-            setError('');
         }
-        catch (err) {
-            console.error("Failed to toggle cancel", err);
-            setError('Failed to update task status.');
-            pushNotice('Failed to update task status.', 'error');
-            fetchTasks();
+        else if (hasDurableMetadata && 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;
         }
-    };
-    const handleToggleInProgress = async (task) => {
-        const newStatus = task.status === 'in-progress' ? 'task' : 'in-progress';
-        setTasks(prev => prev.map(t => t.id === task.id ? { ...t, status: newStatus } : t));
+        if (hasDurableMetadata && !durableMetadataHandled) {
+            legacyCarrierPatch = { ...durableMetadataPatch, ...legacyCarrierPatch };
+            hasLegacyCarriers = true;
+        }
+        if (!hasLegacyCarriers)
+            return true;
         try {
-            const res = await fetch(`/api/taskforce/task/${task.id}`, {
+            const legacyRequestPatch = {
+                ...legacyCarrierPatch,
+                ...(saveSource ? { saveSource } : {}),
+            };
+            const requestInit = {
                 method: 'PATCH',
                 headers: { 'Content-Type': 'application/json' },
-                body: JSON.stringify({ status: newStatus }),
-            });
+                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) {
-                await fetchTasks(true);
-                return;
+                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));
+                return false;
             }
             const updatedTask = await res.json().catch(() => null);
             mergeTaskFromServer(updatedTask);
-            queueWorkspaceSyncFromAuthoritativeTaskState();
+            // 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;
         }
         catch (err) {
-            fetchTasks();
+            console.error("Failed to update task", err);
+            const message = `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));
+            return false;
         }
+    }, [tasks, archivedTasks, pushNotice, mergeTaskFromServer, mutateTaskMetadata, queueWorkspaceSyncFromAuthoritativeTaskState, handleSetStatus, durableTaskMetadataActivationEnabled, durableTaskStatusActivationEnabled, fetchCloudTaskRootPatch]);
+    const handleToggleComplete = async (task) => {
+        const newStatus = task.status === 'done' ? 'task' : 'done';
+        await handleSetStatus(task, newStatus);
+    };
+    const handleToggleCancel = async (task) => {
+        const newStatus = task.status === 'cancelled' ? 'task' : 'cancelled';
+        await handleSetStatus(task, newStatus);
+    };
+    const handleToggleInProgress = async (task) => {
+        const newStatus = task.status === 'in-progress' ? 'task' : 'in-progress';
+        await handleSetStatus(task, newStatus);
     };
     const handleToggleReview = async (task) => {
         const newStatus = task.status === 'review' ? 'task' : 'review';
-        setTasks(prev => prev.map(t => t.id === task.id ? { ...t, status: newStatus } : t));
-        try {
-            const res = await fetch(`/api/taskforce/task/${task.id}`, {
-                method: 'PATCH',
-                headers: { 'Content-Type': 'application/json' },
-                body: JSON.stringify({ status: newStatus }),
-            });
-            if (!res.ok) {
-                await fetchTasks(true);
-                return;
-            }
-            const updatedTask = await res.json().catch(() => null);
-            mergeTaskFromServer(updatedTask);
-            queueWorkspaceSyncFromAuthoritativeTaskState();
-        }
-        catch (err) {
-            fetchTasks();
-        }
+        await handleSetStatus(task, newStatus);
     };
     const handleArchiveTask = async (task) => {
+        if (mutateTaskLifecycle) {
+            try {
+                const durableResult = await mutateTaskLifecycle(task.id, {
+                    mutationKind: 'archive',
+                    cancellation: task.status === 'cancelled',
+                    reason: task.status === 'cancelled' ? (task.canceledReason ?? null) : null,
+                });
+                if (durableResult && finishDurableTaskMutation(durableResult, task.id, {}, tasks, archivedTasks)) {
+                    const archivedConclusively = durableResult.state !== 'rejected'
+                        && durableResult.state !== 'failed'
+                        && durableResult.state !== 'ambiguous';
+                    if (editingTaskId === task.id && archivedConclusively) {
+                        resetForm();
+                        setActiveTab('tasks');
+                    }
+                    return archivedConclusively;
+                }
+                if (!durableResult && durableTaskStatusActivationEnabled) {
+                    throw new Error('Durable task archive activation returned no result.');
+                }
+            }
+            catch (error) {
+                console.error('Durable task archive failed before a conclusive result.', error);
+                const message = 'Task archive confirmation was interrupted. Retry the same action to confirm it safely.';
+                setError(message);
+                pushNotice(message, 'error');
+                return false;
+            }
+        }
         try {
             const isCancelled = task.status === 'cancelled';
             const endpoint = isCancelled ? 'cancel' : 'complete';
-            const res = await fetch(`/api/taskforce/task/${task.id}/${endpoint}`, { method: 'POST' });
+            const url = `/api/taskforce/task/${task.id}/${endpoint}`;
+            const res = await fetchCloudTaskMutation(url, { method: 'POST' }, {}, taskHttpObservedPrecondition(task, task.id), (payload) => (!!payload && typeof payload === 'object'
+                && String(payload.id || '') === task.id));
             if (res.ok) {
                 const archivedTask = await res.json().catch(() => null);
                 const archivedResults = [];
@@ -413,18 +821,21 @@ export function useTaskMutations({ tasks, archivedTasks, editingTaskId, setTasks
                     resetForm();
                     setActiveTab('tasks');
                 }
+                return true;
             }
             else {
                 const data = await res.json().catch(() => ({}));
                 const message = data.error || 'Failed to archive task.';
                 setError(message);
                 pushNotice(message, 'error');
+                return false;
             }
         }
         catch (err) {
             console.error("Failed to archive", err);
             setError('Failed to archive task.');
             pushNotice('Failed to archive task.', 'error');
+            return false;
         }
     };
     const handleBulkArchive = async () => {
@@ -433,6 +844,45 @@ export function useTaskMutations({ tasks, archivedTasks, editingTaskId, setTasks
             return;
         if (!confirm(`Archive ${completedOrCancelled.length} completed/cancelled tasks?`))
             return;
+        if (mutateTaskLifecycle) {
+            let durableStarted = false;
+            let durableCount = 0;
+            for (const task of completedOrCancelled) {
+                try {
+                    const result = await mutateTaskLifecycle(task.id, {
+                        mutationKind: 'archive',
+                        cancellation: task.status === 'cancelled',
+                        reason: task.status === 'cancelled' ? (task.canceledReason ?? null) : null,
+                    });
+                    if (!result || result.state === 'disabled') {
+                        if (!durableStarted && (!durableTaskStatusActivationEnabled || result?.state === 'disabled'))
+                            break;
+                        const message = 'Bulk archive stopped safely because durable capture became unavailable.';
+                        setError(message);
+                        pushNotice(message, 'error');
+                        return;
+                    }
+                    durableStarted = true;
+                    if (finishDurableTaskMutation(result, task.id, {}, tasks, archivedTasks)) {
+                        if (result.state === 'rejected' || result.state === 'failed')
+                            return;
+                        durableCount += 1;
+                    }
+                }
+                catch (error) {
+                    console.error('Durable bulk archive confirmation was interrupted.', error);
+                    const message = 'Bulk archive stopped safely. Retry to confirm the remaining tasks.';
+                    setError(message);
+                    pushNotice(message, 'error');
+                    return;
+                }
+            }
+            if (durableStarted) {
+                pushNotice(`${durableCount} tasks archived`, 'info');
+                setError('');
+                return;
+            }
+        }
         try {
             const res = await fetch('/api/taskforce/bulk-archive', {
                 method: 'POST',
@@ -469,8 +919,32 @@ export function useTaskMutations({ tasks, archivedTasks, editingTaskId, setTasks
         }
     };
     const handleUnarchive = async (id) => {
+        if (mutateTaskLifecycle) {
+            try {
+                const durableResult = await mutateTaskLifecycle(id, { mutationKind: 'unarchive' });
+                if (durableResult && finishDurableTaskMutation(durableResult, id, {}, tasks, archivedTasks)) {
+                    if (durableResult.state !== 'rejected' && durableResult.state !== 'failed') {
+                        pushNotice('Task restored from archive.', 'info');
+                    }
+                    return;
+                }
+                if (!durableResult && durableTaskStatusActivationEnabled) {
+                    throw new Error('Durable task unarchive activation returned no result.');
+                }
+            }
+            catch (error) {
+                console.error('Durable task unarchive failed before a conclusive result.', error);
+                const message = 'Task restore confirmation was interrupted. Retry the same action to confirm it safely.';
+                setError(message);
+                pushNotice(message, 'error');
+                return;
+            }
+        }
         try {
-            const res = await fetch(`/api/taskforce/task/${id}/unarchive`, { method: 'POST' });
+            const url = `/api/taskforce/task/${id}/unarchive`;
+            const observed = archivedTasks.find((task) => task.id === id) || tasks.find((task) => task.id === id);
+            const res = await fetchCloudTaskMutation(url, { method: 'POST' }, {}, taskHttpObservedPrecondition(observed, id), (payload) => (!!payload && typeof payload === 'object'
+                && String(payload.id || '') === id));
             if (res.ok) {
                 const restoredTask = await res.json().catch(() => null);
                 if (restoredTask) {
@@ -492,6 +966,155 @@ export function useTaskMutations({ tasks, archivedTasks, editingTaskId, setTasks
             pushNotice('Failed to unarchive task.', 'error');
         }
     };
+    const handleRestoreSelectedDeletedTasks = useCallback(async (records, restoreDestination = 'previous', onProgress) => {
+        const uniqueRecords = Array.from(new Map(records.map((record) => [record.id, record])).values());
+        const result = {
+            requested: uniqueRecords.length,
+            completed: 0,
+            succeeded: [],
+            failed: [],
+        };
+        const publish = () => onProgress?.({
+            ...result,
+            succeeded: [...result.succeeded],
+            failed: [...result.failed],
+        });
+        const recordFailure = (record, message, code) => {
+            result.failed.push({
+                deletedRecordId: record.id,
+                taskId: record.taskId,
+                title: record.taskSnapshot.title,
+                message,
+                ...(code ? { code } : {}),
+            });
+            result.completed += 1;
+            publish();
+        };
+        const recordSuccess = (record, task) => {
+            mergeTaskFromServer(task);
+            setDeletedTasks((prev) => prev.filter((entry) => (entry.id !== record.id && entry.taskId !== task.id)));
+            workspaceDeletedTaskIdsRef.current.delete(record.id);
+            workspaceDeletedTaskIdsRef.current.delete(record.taskId);
+            workspaceDeletedTaskWatermarksRef.current.delete(record.id);
+            workspaceDeletedTaskWatermarksRef.current.delete(record.taskId);
+            result.succeeded.push(record);
+            result.completed += 1;
+            publish();
+        };
+        if (durableTaskDeleteActivationEnabled) {
+            for (const record of uniqueRecords) {
+                const task = await handleRestoreDeletedTask(record.id, record.taskId, {
+                    silent: true,
+                    restoreDestination,
+                });
+                if (task)
+                    recordSuccess(record, task);
+                else
+                    recordFailure(record, 'Failed to capture or confirm the durable restore.');
+            }
+        }
+        else {
+            for (let offset = 0; offset < uniqueRecords.length; offset += 50) {
+                const chunk = uniqueRecords.slice(offset, offset + 50);
+                const ids = chunk.map((record) => record.id);
+                const body = restoreDestination === 'archive'
+                    ? { ids, restoreDestination }
+                    : { ids };
+                try {
+                    let response;
+                    let prepared = null;
+                    if (durableTaskHttpRootActivationEnabled) {
+                        if (!taskHttpMutationClientRef.current) {
+                            taskHttpMutationClientRef.current = taskHttpMutationClient || createCloudTaskHttpMutationClient();
+                        }
+                        prepared = await taskHttpMutationClientRef.current.prepareUpdate(workspaceId, '/api/taskforce/deleted/restore-batch', body, restoreDestination === 'archive'
+                            ? { deletedRecordIds: ids, restoreDestination }
+                            : { deletedRecordIds: ids });
+                        response = await fetchTaskHttpMutation('/api/taskforce/deleted/restore-batch', {
+                            method: 'POST',
+                            headers: { 'Content-Type': 'application/json' },
+                            body: JSON.stringify(body),
+                        }, prepared.operationId);
+                    }
+                    else {
+                        response = await requestDeletedEndpoint('/restore-batch', {
+                            method: 'POST',
+                            headers: { 'Content-Type': 'application/json' },
+                            body: JSON.stringify(body),
+                        });
+                    }
+                    const payload = await response.json().catch(() => ({}));
+                    if (prepared && (response.ok || await isConclusiveTaskHttpResponse(response))) {
+                        await taskHttpMutationClientRef.current?.confirmUpdate(prepared.fingerprint, prepared.operationId);
+                    }
+                    if (!response.ok) {
+                        const message = String(payload.error || 'Failed to restore the selected Trash records.');
+                        chunk.forEach((record) => recordFailure(record, message));
+                        continue;
+                    }
+                    const recordsById = new Map(chunk.map((record) => [record.id, record]));
+                    const completedIds = new Set();
+                    for (const item of payload.results || []) {
+                        const deletedRecordId = String(item.deletedRecordId || '').trim();
+                        const record = recordsById.get(deletedRecordId);
+                        if (!record || !item.task)
+                            continue;
+                        const task = normalizeTaskFromApi(item.task);
+                        if (task.id !== record.taskId)
+                            continue;
+                        completedIds.add(deletedRecordId);
+                        recordSuccess(record, task);
+                    }
+                    for (const error of payload.errors || []) {
+                        const deletedRecordId = String(error.id || '').trim();
+                        const record = recordsById.get(deletedRecordId);
+                        if (!record || completedIds.has(deletedRecordId))
+                            continue;
+                        completedIds.add(deletedRecordId);
+                        recordFailure(record, String(error.message || 'Failed to restore the deleted task.'), error.code ? String(error.code) : undefined);
+                    }
+                    for (const record of chunk) {
+                        if (!completedIds.has(record.id)) {
+                            recordFailure(record, 'The restore response did not include this deleted record.');
+                        }
+                    }
+                }
+                catch (error) {
+                    const message = error instanceof Error
+                        ? error.message
+                        : 'The restore request was interrupted.';
+                    chunk.forEach((record) => recordFailure(record, message));
+                }
+            }
+            queueWorkspaceSyncFromAuthoritativeTaskState();
+        }
+        if (result.failed.length > 0) {
+            const message = `${result.succeeded.length} restored; ${result.failed.length} failed and remain selected.`;
+            setError(message);
+            pushNotice(message, 'error');
+        }
+        else if (result.succeeded.length > 0) {
+            setError('');
+            pushNotice(restoreDestination === 'archive'
+                ? `${result.succeeded.length} task${result.succeeded.length === 1 ? '' : 's'} restored to Archive.`
+                : `${result.succeeded.length} task${result.succeeded.length === 1 ? '' : 's'} restored from Trash.`, 'info');
+        }
+        return result;
+    }, [
+        durableTaskDeleteActivationEnabled,
+        durableTaskHttpRootActivationEnabled,
+        handleRestoreDeletedTask,
+        mergeTaskFromServer,
+        pushNotice,
+        queueWorkspaceSyncFromAuthoritativeTaskState,
+        requestDeletedEndpoint,
+        setDeletedTasks,
+        setError,
+        taskHttpMutationClient,
+        workspaceDeletedTaskIdsRef,
+        workspaceDeletedTaskWatermarksRef,
+        workspaceId,
+    ]);
     const handleCopyId = (e, id) => {
         e.stopPropagation();
         navigator.clipboard.writeText(id);
@@ -506,6 +1129,7 @@ export function useTaskMutations({ tasks, archivedTasks, editingTaskId, setTasks
         // Handlers
         handleDelete,
         handleUpdateTask,
+        handleSetStatus,
         handleToggleComplete,
         handleToggleCancel,
         handleToggleInProgress,
@@ -514,6 +1138,7 @@ export function useTaskMutations({ tasks, archivedTasks, editingTaskId, setTasks
         handleBulkArchive,
         handleUnarchive,
         handleRestoreDeletedTask,
+        handleRestoreSelectedDeletedTasks,
         handlePermanentlyDeleteDeletedTask,
         handleEmptyDeletedTasks,
         handleCopyId,