@taskforcehq/taskforce 0.3.328 → 0.3.330

package/dist/hooks/useTaskforce.js

@@ -41,6 +41,8 @@ import { resolveRuntimeModeContract } from '../shared/runtimeContract';
 import { DEFAULT_TYPE_VALUE } from '../shared/taxonomyDefaults.js';
 import { resolveClientDeploymentConfig } from '../config/clientDeployment';
 import { resolveTaskforceMcpBaseUrlFromBaseUrl } from '../config/cloudEnvironment';
+import { applyEditorDraftToTask, formatTaskEditorConflictFields, preserveUnresolvedTaskEditorConflicts, reconcileTaskEditorDraft, resolveTaskEditorConflicts, taskToEditorDraft, } from '../utils/taskEditorReconciliation';
+import { isResolvedFeatureAccessMap, } from '../runtime/appGates';
 import { buildBootstrapTraceId, withBootstrapTraceHeader } from '../utils/bootstrapTrace';
 import { buildTaskforceCredentialLoginPayload } from '../utils/authLogin';
 import { createDefaultAssigneeOptions } from '../utils/assignees';
@@ -59,6 +61,7 @@ import { useCurrentTaskRelations } from './tasks/useCurrentTaskRelations';
 import { useTaskEditorNavigation } from './tasks/useTaskEditorNavigation';
 import { useTaskFilters } from './tasks/useTaskFilters';
 import { useTaskFormActions } from './tasks/useTaskFormActions';
+import { useTaskDescriptionImageDraftRecovery } from './tasks/useTaskDescriptionImageDraftRecovery';
 import { useTaskRelationships } from './tasks/useTaskRelationships';
 import { useTaskActions } from './tasks/useTaskActions';
 import { clearPersistedWorkspaceId, logBootstrapDebug, readPersistedWorkspaceId, writePersistedWorkspaceId } from './workspace/workspaceLocalState';
@@ -80,6 +83,19 @@ import { createTaskInvalidationScope, mergeTaskInvalidationScopes, resolveTaskIn
 import { createCloudWorkstreamHttpMutationClient, fetchWorkstreamHttpMutation, isConclusiveWorkstreamHttpResponse, selectCreatedWorkstreamAfterRefresh, } from './workstreams/workstreamHttpMutation';
 import { dispatchTaskforceWorkspaceResourcesInvalidated } from '../utils/workspaceResourceEvents';
 import { dispatchTaskforceAuthSessionChanged } from '../utils/authSessionEvents';
+export function buildRelationshipTasks(tasks, archivedTasks, taskDetails, editingTaskId) {
+    const byId = new Map();
+    for (const task of archivedTasks)
+        byId.set(task.id, task);
+    for (const task of tasks)
+        byId.set(task.id, task);
+    if (editingTaskId && byId.has(editingTaskId)) {
+        const currentDetail = taskDetails.find((task) => task.id === editingTaskId);
+        if (currentDetail)
+            byId.set(editingTaskId, currentDetail);
+    }
+    return Array.from(byId.values());
+}
 function upsertEntityById(items, nextItem) {
     const existingIndex = items.findIndex((item) => item.id === nextItem.id);
     if (existingIndex === -1) {
@@ -208,6 +224,7 @@ export function useTaskforce({ config = {}, initialTaskId, initialActivityEntryI
         authSource: '',
         workspaceMode: '',
         workspaceSwitchingEnabled: null,
+        appGates: undefined,
         syncV3TaskMetadataActivation: false,
         syncV3TaskCreateActivation: false,
         syncV3TaskStatusActivation: false,
@@ -267,6 +284,9 @@ export function useTaskforce({ config = {}, initialTaskId, initialActivityEntryI
                     workspaceSwitchingEnabled: typeof cfg.workspaceSwitchingEnabled === 'boolean'
                         ? Boolean(cfg.workspaceSwitchingEnabled)
                         : (workspaceMode === 'multi-cloud'),
+                    appGates: isResolvedFeatureAccessMap(cfg.appGates)
+                        ? cfg.appGates
+                        : undefined,
                     syncV3TaskMetadataActivation: cfg.syncV3?.taskMetadataActivation === true,
                     syncV3TaskCreateActivation: cfg.syncV3?.taskCreateActivation === true,
                     syncV3TaskStatusActivation: cfg.syncV3?.taskStatusActivation === true,
@@ -375,6 +395,9 @@ export function useTaskforce({ config = {}, initialTaskId, initialActivityEntryI
         const isCloudScopedPath = path.startsWith('/api/taskforce/auth/')
             || path.startsWith('/api/taskforce/account/')
             || path.startsWith('/api/taskforce/billing/')
+            || /^\/api\/taskforce\/model-connections(?:[/?]|$)/i.test(path)
+            || /^\/api\/taskforce\/agents\/model-catalog(?:\?|$)/i.test(path)
+            || /^\/api\/taskforce\/agents\/[^/]+\/connection-binding(?:\?|$)/i.test(path)
             || path.startsWith('/api/taskforce/sync/')
             || path.startsWith('/api/taskforce/settings/mcp/');
         if (!isCloudHost && isCloudScopedPath) {
@@ -619,6 +642,11 @@ export function useTaskforce({ config = {}, initialTaskId, initialActivityEntryI
     const [manualComplexityEnabled, setManualComplexityEnabled] = useState(false);
     const [checklistDropdownEnabled, setChecklistDropdownEnabled] = useState(true);
     const [showTaskCardStatusLabel, setShowTaskCardStatusLabel] = useState(false);
+    const [showTaskCardDescription, setShowTaskCardDescription] = useState(true);
+    const [showTaskCardAttachments, setShowTaskCardAttachments] = useState(true);
+    const [showTaskCardChecklistProgress, setShowTaskCardChecklistProgress] = useState(true);
+    const [showTaskCardLatestActivity, setShowTaskCardLatestActivity] = useState(true);
+    const [tintTaskCardActivityBackground, setTintTaskCardActivityBackground] = useState(false);
     const [serverHostRoot, setServerHostRoot] = useState('');
     const [returnTab, setReturnTab] = useState(null);
     useTaskforceApiRouting({
@@ -666,6 +694,12 @@ export function useTaskforce({ config = {}, initialTaskId, initialActivityEntryI
     const deletedHydrationRequestRef = useRef(null);
     const [loadingTasks, setLoadingTasks] = useState(false);
     const [editingTaskId, setEditingTaskId] = useState(null);
+    const editorBaselineRef = useRef(null);
+    const [editorBaseline, setEditorBaseline] = useState(null);
+    const [editingTaskRevisionConflict, setEditingTaskRevisionConflict] = useState(null);
+    const editingTaskRevisionConflictRef = useRef(null);
+    const reconcileOpenTaskWithRemoteRef = useRef(() => null);
+    const refreshingTaskRevisionRef = useRef(null);
     const [pendingOpenTaskId, setPendingOpenTaskId] = useState(null);
     const setPendingOpenTaskIdFromPersistedState = useCallback((taskId) => {
         if (String(initialTaskId || '').trim())
@@ -852,7 +886,8 @@ export function useTaskforce({ config = {}, initialTaskId, initialActivityEntryI
     }, [AUTH_REQUIRED_ERROR, runtimeMode]);
     // === SECTION: Task Data ===
     // Delegated to useTaskData — see src/hooks/useTaskData.ts
-    const { tasksRef, archivedTasksRef, recentlyChangedTaskIds, markRecentlyChangedTasks, fetchTasks: fetchTasksBase, fetchArchive: fetchArchiveBase, refreshTaskCollections: refreshTaskCollectionsBase, refreshTaskCollectionsFromInvalidation: refreshTaskCollectionsFromInvalidationBase, mergeTaskFromServer, getTaskRevisionKey } = useTaskData({
+    const pendingTaskMetadataOverlaysRef = useRef(new Map());
+    const { tasksRef, archivedTasksRef, taskDetails, staleTaskDetailRevisions, recentlyChangedTaskIds, markRecentlyChangedTasks, fetchTasks: fetchTasksBase, fetchArchive: fetchArchiveBase, loadTaskDetail, cancelTaskDetailLoad, refreshTaskCollections: refreshTaskCollectionsBase, refreshTaskCollectionsFromInvalidation: refreshTaskCollectionsFromInvalidationBase, mergeTaskFromServer, getTaskRevisionKey } = useTaskData({
         tasks,
         archivedTasks,
         setTasks,
@@ -863,7 +898,10 @@ export function useTaskforce({ config = {}, initialTaskId, initialActivityEntryI
         shouldDeferProtectedApiCalls,
         shouldBlockProtectedApiCalls,
         handleUnauthorized,
-        authRequiredForApi
+        authRequiredForApi,
+        setError,
+        setLoading,
+        pendingTaskMetadataOverlaysRef,
     });
     useEffect(() => {
         if (workspaceTransitionEpoch === 0)
@@ -885,6 +923,7 @@ export function useTaskforce({ config = {}, initialTaskId, initialActivityEntryI
         deletedHydrationRequestRef.current = null;
         setTasks([]);
         setArchivedTasks([]);
+        pendingTaskMetadataOverlaysRef.current.clear();
         setInitiatives([]);
         setWorkstreams([]);
         setPlanningBootstrapTaskSummaries([]);
@@ -1330,7 +1369,7 @@ export function useTaskforce({ config = {}, initialTaskId, initialActivityEntryI
     const setUserGlobalSyncErrorRef = useRef(() => undefined);
     const checkAuthSessionImplRef = useRef(async () => false);
     const checkAuthSession = useCallback((options) => checkAuthSessionImplRef.current(options), []);
-    const { userGlobalSyncStatus, setUserGlobalSyncStatus, userGlobalSyncError, setUserGlobalSyncError, workspaceLastPullAt, workspaceLastPushAt, workspaceLastErrorAt, workspaceLastErrorMessage, workspaceLastSuccessfulSyncAt, workspaceCloudSyncEnabled, workspaceSyncPhase, workspaceSyncSetupIntent, workspaceSyncStatus, workspaceSyncSummary, workspaceSyncRecommendedAction, workspaceSyncBusy, workspaceSyncPendingChanges, workspaceTaskRelationships, localCoordinatorDataVersion, localCoordinatorStatus, switchLocalCoordinatorWorkspace, transferLocalCoordinatorOwnership, workspacePushInFlightRef, workspacePullInFlightRef, workspaceLastPushedSignatureRef, workspacePendingSignatureRef, workspaceLastPushedTaskIdsRef, workspaceDeletedTaskIdsRef, workspaceDeletedTaskWatermarksRef, workspacePullCursorRef, clearWorkspaceRetry, persistWorkspaceSyncPatch, loadWorkspaceSyncState, applyWorkspaceSyncStateSnapshot, syncUserGlobalSettings, buildWorkspaceSyncSignature, pushWorkspaceChangesToCloud, saveWorkspaceCloudSyncSettings, retryUserGlobalSettingsSync, retryWorkspaceCloudSync, resetWorkspaceSyncCursorAndPull, getWorkspaceSyncDiagnostics } = useSyncOrchestrator({
+    const { userGlobalSyncStatus, setUserGlobalSyncStatus, userGlobalSyncError, setUserGlobalSyncError, workspaceLastPullAt, workspaceLastPushAt, workspaceLastErrorAt, workspaceLastErrorMessage, workspaceLastSuccessfulSyncAt, workspaceCloudSyncEnabled, workspaceSyncPhase, workspaceSyncSetupIntent, workspaceSyncStatus, workspaceSyncSummary, workspaceSyncRecommendedAction, workspaceSyncBusy, workspaceSyncPendingChanges, workspaceTaskRelationships, localCoordinatorDataVersion, localCoordinatorStatus, switchLocalCoordinatorWorkspace, transferLocalCoordinatorOwnership, clearLocalCoordinatorCredential, workspacePushInFlightRef, workspacePullInFlightRef, workspaceLastPushedSignatureRef, workspacePendingSignatureRef, workspaceLastPushedTaskIdsRef, workspaceDeletedTaskIdsRef, workspaceDeletedTaskWatermarksRef, workspacePullCursorRef, clearWorkspaceRetry, persistWorkspaceSyncPatch, loadWorkspaceSyncState, applyWorkspaceSyncStateSnapshot, syncUserGlobalSettings, buildWorkspaceSyncSignature, pushWorkspaceChangesToCloud, saveWorkspaceCloudSyncSettings, retryUserGlobalSettingsSync, retryWorkspaceCloudSync, resetWorkspaceSyncCursorAndPull, getWorkspaceSyncDiagnostics } = useSyncOrchestrator({
         currentWorkspaceId,
         cloudAuthConfigured,
         runtimeMode,
@@ -1445,7 +1484,15 @@ export function useTaskforce({ config = {}, initialTaskId, initialActivityEntryI
         configLoaded,
         referenceDataLoaded,
         assigneeOptionsLoaded,
-        assigneeOptions
+        assigneeOptions,
+        runtimeMode,
+        workspaceId: currentWorkspaceId,
+        cloudTaskSearchEnabled: runtimeMode === 'cloud'
+            && isAuthenticated
+            && taskScope !== 'deleted'
+            && !shouldDeferProtectedApiCalls
+            && !shouldBlockProtectedApiCalls,
+        cloudTaskSearchScope: taskScope === 'archived' ? 'archive' : 'active',
     });
     setUserGlobalSyncStatusRef.current = setUserGlobalSyncStatus;
     setUserGlobalSyncErrorRef.current = setUserGlobalSyncError;
@@ -1549,7 +1596,7 @@ export function useTaskforce({ config = {}, initialTaskId, initialActivityEntryI
     const referenceDataRequestRef = useRef(null);
     const workspaceListHydratedRef = useRef(false);
     const hasBootstrappedDataRef = useRef(false);
-    const { handleSaveSettings, handleSaveTheme, handleSaveGlobalTheme, handleJsonBackupEnabledChange, handleSaveGlobalJsonBackupEnabled, handleSaveGlobalWeekStartsOn, handleSaveLocale, handleManualComplexityEnabledChange, handleChecklistDropdownEnabledChange, handleShowTaskCardStatusLabelChange, handleResetProjectToGlobal } = useSettingsPersistence({
+    const { handleSaveSettings, handleSaveTheme, handleSaveGlobalTheme, handleUseGlobalThemeDefault, handleJsonBackupEnabledChange, handleSaveGlobalJsonBackupEnabled, handleUseGlobalJsonBackupDefault, handleSaveGlobalWeekStartsOn, handleSaveLocale, handleManualComplexityEnabledChange, handleChecklistDropdownEnabledChange, handleShowTaskCardStatusLabelChange, handleShowTaskCardDescriptionChange, handleShowTaskCardAttachmentsChange, handleShowTaskCardChecklistProgressChange, handleShowTaskCardLatestActivityChange, handleTintTaskCardActivityBackgroundChange } = useSettingsPersistence({
         keyShortcut,
         themeUseGlobalDefault,
         runtimeMode,
@@ -1566,7 +1613,12 @@ export function useTaskforce({ config = {}, initialTaskId, initialActivityEntryI
         setLocale,
         setManualComplexityEnabled,
         setChecklistDropdownEnabled,
-        setShowTaskCardStatusLabel
+        setShowTaskCardStatusLabel,
+        setShowTaskCardDescription,
+        setShowTaskCardAttachments,
+        setShowTaskCardChecklistProgress,
+        setShowTaskCardLatestActivity,
+        setTintTaskCardActivityBackground
     });
     useEffect(() => {
         if (runtimeMode !== 'cloud')
@@ -1767,6 +1819,36 @@ export function useTaskforce({ config = {}, initialTaskId, initialActivityEntryI
         else {
             setShowTaskCardStatusLabel(false);
         }
+        if (typeof data.showTaskCardDescription === 'boolean') {
+            setShowTaskCardDescription(data.showTaskCardDescription);
+        }
+        else {
+            setShowTaskCardDescription(true);
+        }
+        if (typeof data.showTaskCardAttachments === 'boolean') {
+            setShowTaskCardAttachments(data.showTaskCardAttachments);
+        }
+        else {
+            setShowTaskCardAttachments(true);
+        }
+        if (typeof data.showTaskCardChecklistProgress === 'boolean') {
+            setShowTaskCardChecklistProgress(data.showTaskCardChecklistProgress);
+        }
+        else {
+            setShowTaskCardChecklistProgress(true);
+        }
+        if (typeof data.showTaskCardLatestActivity === 'boolean') {
+            setShowTaskCardLatestActivity(data.showTaskCardLatestActivity);
+        }
+        else {
+            setShowTaskCardLatestActivity(true);
+        }
+        if (typeof data.tintTaskCardActivityBackground === 'boolean') {
+            setTintTaskCardActivityBackground(data.tintTaskCardActivityBackground);
+        }
+        else {
+            setTintTaskCardActivityBackground(false);
+        }
     }, [applyResolvedWorkspaceId, commitCurrentWorkspaceId, configLoaded, currentWorkspaceIdRef]);
     const fetchBuildInfo = useCallback(async () => {
         const startedAt = typeof performance !== 'undefined' ? performance.now() : Date.now();
@@ -2693,6 +2775,7 @@ export function useTaskforce({ config = {}, initialTaskId, initialActivityEntryI
     }, [abortWorkspaceScopedRequests, resetPersistedUiStateLoad, setArchivedTasks, setTasks]);
     const logout = useCallback(async () => {
         try {
+            await clearLocalCoordinatorCredential().catch(() => false);
             if (cloudAuthConfigured) {
                 await fetch(resolveCloudAuthUrl('/api/taskforce/auth/logout'), {
                     method: 'POST',
@@ -2750,6 +2833,7 @@ export function useTaskforce({ config = {}, initialTaskId, initialActivityEntryI
     }, [
         abortWorkspaceScopedRequests,
         authRequiredForApi,
+        clearLocalCoordinatorCredential,
         clearPersistedWorkspaceId,
         commitCurrentWorkspaceId,
         resolveCloudAuthUrl,
@@ -3301,13 +3385,8 @@ export function useTaskforce({ config = {}, initialTaskId, initialActivityEntryI
         coordinatorDataVersion: localCoordinatorDataVersion,
     });
     const relationshipTasks = useMemo(() => {
-        const byId = new Map();
-        for (const task of archivedTasks)
-            byId.set(task.id, task);
-        for (const task of tasks)
-            byId.set(task.id, task);
-        return Array.from(byId.values());
-    }, [tasks, archivedTasks]);
+        return buildRelationshipTasks(tasks, archivedTasks, taskDetails, editingTaskId);
+    }, [tasks, archivedTasks, taskDetails, editingTaskId]);
     const deletedRelationshipTasks = useMemo(() => deletedTasks.map((entry) => ({
         ...entry.taskSnapshot,
         isDeleted: true,
@@ -3463,13 +3542,25 @@ export function useTaskforce({ config = {}, initialTaskId, initialActivityEntryI
         setActiveTab__internal(tab);
     }, [activeTab]);
     const flushAutoSaveRef = useRef(async () => true);
-    const { handleNavigation, handleClose, resetForm, resolveTaskIdInput, resolveWorkstreamIdInput, handleEdit, handleOpenTaskById, returnToPreviousTask, clearReturnToParentTask } = useTaskEditorNavigation({
+    const adoptTaskEditorBaseline = useCallback((task) => {
+        const baseline = {
+            taskId: task.id,
+            task,
+            draft: taskToEditorDraft(task),
+        };
+        editorBaselineRef.current = baseline;
+        setEditorBaseline(baseline);
+        editingTaskRevisionConflictRef.current = null;
+        setEditingTaskRevisionConflict(null);
+    }, []);
+    const { handleNavigation, handleClose, resetForm, resolveTaskIdInput, resolveWorkstreamIdInput, handleEdit, applyTaskToEditor, handleOpenTaskById, returnToPreviousTask, clearReturnToParentTask } = useTaskEditorNavigation({
         activeCategories,
         activeTypes,
         activeTab,
         attachments,
         checklistItems,
         comments,
+        cancelTaskDetailLoad,
         description,
         editingTaskId,
         flushPendingAutoSave: () => flushAutoSaveRef.current(),
@@ -3477,7 +3568,9 @@ export function useTaskforce({ config = {}, initialTaskId, initialActivityEntryI
         getPreferredCategoryValue,
         getTitleDraft,
         lastUsedCategory,
+        loadTaskDetail,
         newCommentText,
+        onTaskApplied: adoptTaskEditorBaseline,
         relationshipTasks,
         workstreams,
         showArchive,
@@ -3510,6 +3603,43 @@ export function useTaskforce({ config = {}, initialTaskId, initialActivityEntryI
         taskReturnTrail,
         title,
     });
+    const readCurrentTaskEditorDraft = useCallback(() => {
+        const resolvedWorkstream = workstreamInput.trim()
+            ? resolveWorkstreamIdInput(workstreamInput)
+            : null;
+        return {
+            title: getTitleDraft(),
+            description: getDescriptionDraft(),
+            category: typeof category === 'string' ? category : String(category.label || ''),
+            type: typeof type === 'string' ? type : String(type.label || ''),
+            priority,
+            complexity: Number(complexity) || 3,
+            status,
+            assignee,
+            scheduledDate,
+            dueDate,
+            workstreamId: resolvedWorkstream?.id || workstreamInput.trim(),
+            taxonomies: { ...formTaxonomies },
+            checklistItems: [...checklistItems],
+            attachments: getAttachmentsDraft(),
+        };
+    }, [
+        assignee,
+        category,
+        checklistItems,
+        complexity,
+        dueDate,
+        formTaxonomies,
+        getAttachmentsDraft,
+        getDescriptionDraft,
+        getTitleDraft,
+        priority,
+        resolveWorkstreamIdInput,
+        scheduledDate,
+        status,
+        type,
+        workstreamInput,
+    ]);
     useEffect(() => {
         const normalizedTaskId = String(pendingOpenTaskId || '').trim();
         if (!uiStateReady || !normalizedTaskId)
@@ -3805,10 +3935,45 @@ export function useTaskforce({ config = {}, initialTaskId, initialActivityEntryI
         isAuthenticated,
         dispatchEnabled: workspaceCloudSyncEnabled,
     });
+    const handleTaskRevisionConflict = useCallback(async (taskId, _currentDetailRevision) => {
+        if (taskId !== editingTaskId)
+            return { handled: false };
+        const task = [...tasks, ...archivedTasks].find((candidate) => candidate.id === taskId);
+        if (!task)
+            return { handled: false };
+        const detail = await loadTaskDetail(task, {
+            force: true,
+            shouldCommit: () => editorBaselineRef.current?.taskId === taskId,
+        });
+        if (!detail || editorBaselineRef.current?.taskId !== taskId)
+            return { handled: false };
+        const reconciliation = reconcileOpenTaskWithRemoteRef.current(detail, 'save');
+        return {
+            handled: true,
+            retryDetailRevision: reconciliation?.conflicts.length === 0
+                ? detail.detailRevision
+                : undefined,
+            retryPatch: reconciliation?.conflicts.length === 0
+                ? applyEditorDraftToTask(detail, reconciliation.merged)
+                : undefined,
+        };
+    }, [archivedTasks, editingTaskId, loadTaskDetail, tasks]);
+    const handleTaskMutationAccepted = useCallback((task) => {
+        if (task.id !== editingTaskId)
+            return;
+        if (editingTaskRevisionConflictRef.current?.taskId === task.id) {
+            reconcileOpenTaskWithRemoteRef.current(task, 'refresh');
+            return;
+        }
+        adoptTaskEditorBaseline(task);
+    }, [adoptTaskEditorBaseline, editingTaskId]);
     const { copiedId, handleDelete, handleUpdateTask, handleSetStatus, handleToggleComplete, handleToggleCancel, handleToggleInProgress, handleToggleReview, handleArchiveTask, handleBulkArchive, handleUnarchive, handleRestoreDeletedTask, handleRestoreSelectedDeletedTasks, handlePermanentlyDeleteDeletedTask, handleEmptyDeletedTasks, handleCopyId, queueWorkspaceSyncFromAuthoritativeTaskState, } = useTaskActions({
         tasks,
         archivedTasks,
         editingTaskId,
+        editingTaskDetailRevision: editorBaseline?.taskId === editingTaskId
+            ? editorBaseline.task.detailRevision || null
+            : null,
         setTasks,
         setArchivedTasks,
         setDeletedTasks,
@@ -3840,24 +4005,20 @@ export function useTaskforce({ config = {}, initialTaskId, initialActivityEntryI
         durableTaskDeleteActivationEnabled: taskDeleteActivationEnabled,
         durableTaskHttpRootActivationEnabled: runtimeConfigOverride.syncV3TaskCloudHttpRootActivation,
         workspaceId: currentWorkspaceId,
+        onTaskRevisionConflict: handleTaskRevisionConflict,
+        onTaskMutationAccepted: handleTaskMutationAccepted,
+        pendingTaskMetadataOverlaysRef,
     });
+    const { resolveDraft: resolveDescriptionImageDraft } = useTaskDescriptionImageDraftRecovery(currentWorkspaceId, authUserId);
     const promoteDescriptionImageDraft = useCallback(async () => {
         const draftId = descriptionImageDraftIdRef.current;
-        const response = await fetch('/api/taskforce/context-upload/draft/promote', {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify({
-                workspaceId: currentWorkspaceId,
-                draftUploadId: draftId,
-                uploadPurpose: 'task-description-draft',
-            }),
-        });
-        if (!response.ok) {
-            throw new Error('Task was created, but its draft upload records could not be finalized.');
-        }
         rotateDescriptionImageDraftId();
-    }, [currentWorkspaceId, rotateDescriptionImageDraftId]);
-    const { autoSaveState, flushAutoSave, scheduleWarningPrompt, handleSubmit, confirmScheduleWarning, cancelScheduleWarning, handleAddComment } = useTaskFormActions({
+        await resolveDescriptionImageDraft({
+            draftUploadId: draftId,
+            resolution: 'promote',
+        });
+    }, [resolveDescriptionImageDraft, rotateDescriptionImageDraftId]);
+    const { autoSaveState, hasUnsavedChanges, flushAutoSave, scheduleWarningPrompt, handleSubmit, confirmScheduleWarning, cancelScheduleWarning, handleAddComment } = useTaskFormActions({
         activeCategories,
         activeTab,
         apiEndpoint,
@@ -3875,6 +4036,8 @@ export function useTaskforce({ config = {}, initialTaskId, initialActivityEntryI
         workspaceId: currentWorkspaceId,
         updateTask: handleUpdateTask,
         editingTaskId,
+        editorBaselineDraft: editorBaseline?.taskId === editingTaskId ? editorBaseline.draft : null,
+        revisionConflict: editingTaskRevisionConflict?.taskId === editingTaskId,
         fetchTasks,
         formTaxonomies,
         getAttachmentsDraft,
@@ -3907,27 +4070,166 @@ export function useTaskforce({ config = {}, initialTaskId, initialActivityEntryI
         textDraftOccupied,
         type
     });
+    const reconcileOpenTaskWithRemote = useCallback((remoteTask, source) => {
+        if (!editingTaskId || remoteTask.id !== editingTaskId)
+            return null;
+        const previousBaseline = editorBaselineRef.current?.taskId === editingTaskId
+            ? editorBaselineRef.current
+            : { taskId: editingTaskId, task: remoteTask, draft: taskToEditorDraft(remoteTask) };
+        const localDraft = readCurrentTaskEditorDraft();
+        const remoteDraft = taskToEditorDraft(remoteTask);
+        const nextReconciliation = reconcileTaskEditorDraft(previousBaseline.draft, localDraft, remoteDraft);
+        const unresolvedConflicts = editingTaskRevisionConflictRef.current?.taskId === editingTaskId
+            ? editingTaskRevisionConflictRef.current.reconciliation.conflicts
+            : [];
+        const reconciliation = {
+            ...nextReconciliation,
+            conflicts: preserveUnresolvedTaskEditorConflicts(unresolvedConflicts, nextReconciliation.conflicts, localDraft, remoteDraft),
+        };
+        const mergedTask = applyEditorDraftToTask(remoteTask, reconciliation.merged);
+        const nextBaseline = { taskId: editingTaskId, task: remoteTask, draft: remoteDraft };
+        editorBaselineRef.current = nextBaseline;
+        setEditorBaseline(nextBaseline);
+        applyTaskToEditor(mergedTask, { preserveReturnTrail: true, adoptAsBaseline: false });
+        setAttachmentsDirty(JSON.stringify(reconciliation.merged.attachments) !== JSON.stringify(remoteDraft.attachments));
+        setError('');
+        if (reconciliation.conflicts.length > 0) {
+            const nextConflict = {
+                taskId: editingTaskId,
+                detailRevision: remoteTask.detailRevision || 'unknown',
+                source,
+                reconciliation,
+                remoteTask,
+                remoteDraft,
+            };
+            editingTaskRevisionConflictRef.current = nextConflict;
+            setEditingTaskRevisionConflict(nextConflict);
+        }
+        else {
+            editingTaskRevisionConflictRef.current = null;
+            setEditingTaskRevisionConflict(null);
+            if (reconciliation.remoteChangedFields.length > 0) {
+                pushNotice('Task updated', 'info', 2200);
+            }
+        }
+        return reconciliation;
+    }, [
+        applyTaskToEditor,
+        editingTaskId,
+        pushNotice,
+        readCurrentTaskEditorDraft,
+        setAttachmentsDirty,
+        setError,
+    ]);
+    reconcileOpenTaskWithRemoteRef.current = reconcileOpenTaskWithRemote;
+    const resolveEditingTaskConflict = useCallback((resolution) => {
+        const conflict = editingTaskRevisionConflict;
+        if (!conflict || conflict.taskId !== editingTaskId)
+            return;
+        const resolvedDraft = resolveTaskEditorConflicts(conflict.reconciliation, conflict.remoteDraft, resolution, readCurrentTaskEditorDraft());
+        const resolvedTask = applyEditorDraftToTask(conflict.remoteTask, resolvedDraft);
+        applyTaskToEditor(resolvedTask, { preserveReturnTrail: true, adoptAsBaseline: false });
+        setAttachmentsDirty(JSON.stringify(resolvedDraft.attachments) !== JSON.stringify(conflict.remoteDraft.attachments));
+        editingTaskRevisionConflictRef.current = null;
+        setEditingTaskRevisionConflict(null);
+        setError('');
+        clearNotice();
+        const statusWasConflicted = conflict.reconciliation.conflicts.some((item) => item.field === 'status');
+        if (resolution === 'local'
+            && statusWasConflicted
+            && resolvedDraft.status !== conflict.remoteDraft.status) {
+            void handleSetStatus(conflict.remoteTask, resolvedDraft.status);
+        }
+    }, [
+        applyTaskToEditor,
+        clearNotice,
+        editingTaskId,
+        editingTaskRevisionConflict,
+        handleSetStatus,
+        readCurrentTaskEditorDraft,
+        setAttachmentsDirty,
+        setError,
+    ]);
+    useEffect(() => {
+        const conflict = editingTaskRevisionConflict;
+        if (!conflict || conflict.taskId !== editingTaskId)
+            return;
+        const fields = formatTaskEditorConflictFields(conflict.reconciliation.conflicts);
+        const fieldSummary = fields.length > 0 ? fields.join(', ') : 'task fields';
+        pushNotice(`${fieldSummary.charAt(0).toUpperCase()}${fieldSummary.slice(1)} also changed elsewhere.`, 'info', undefined, {
+            label: 'Use latest',
+            primary: true,
+            onAction: () => resolveEditingTaskConflict('latest'),
+            secondaryLabel: 'Keep mine',
+            onSecondaryAction: () => resolveEditingTaskConflict('local'),
+            dismissible: false,
+            ownerKey: `task-editor-conflict:${conflict.taskId}:${conflict.detailRevision}`,
+        });
+    }, [editingTaskId, editingTaskRevisionConflict, pushNotice, resolveEditingTaskConflict]);
+    useEffect(() => {
+        if (!editingTaskId) {
+            refreshingTaskRevisionRef.current = null;
+            setEditingTaskRevisionConflict(null);
+            editingTaskRevisionConflictRef.current = null;
+            editorBaselineRef.current = null;
+            setEditorBaseline(null);
+            return;
+        }
+        const staleRevision = staleTaskDetailRevisions[editingTaskId];
+        if (!staleRevision) {
+            refreshingTaskRevisionRef.current = null;
+            return;
+        }
+        const summary = [...tasks, ...archivedTasks].find((task) => task.id === editingTaskId);
+        if (!summary)
+            return;
+        const refreshKey = `${editingTaskId}:${staleRevision}`;
+        if (refreshingTaskRevisionRef.current === refreshKey)
+            return;
+        refreshingTaskRevisionRef.current = refreshKey;
+        void loadTaskDetail(summary, {
+            shouldCommit: () => editorBaselineRef.current?.taskId === editingTaskId,
+        }).then((detail) => {
+            if (editorBaselineRef.current?.taskId !== editingTaskId)
+                return;
+            if (!detail) {
+                setError('The latest task update could not be loaded. Your local draft has been preserved.');
+                return;
+            }
+            reconcileOpenTaskWithRemote(detail, 'refresh');
+        }).finally(() => {
+            if (refreshingTaskRevisionRef.current === refreshKey) {
+                refreshingTaskRevisionRef.current = null;
+            }
+        });
+    }, [
+        archivedTasks,
+        editingTaskId,
+        loadTaskDetail,
+        reconcileOpenTaskWithRemote,
+        setError,
+        staleTaskDetailRevisions,
+        tasks,
+    ]);
     const discardDescriptionImageDraft = useCallback(async () => {
         const draftId = descriptionImageDraftIdRef.current;
         rotateDescriptionImageDraftId();
         try {
             await awaitPendingDescriptionImageUpload();
-            const response = await fetch('/api/taskforce/context-upload/draft/discard', {
-                method: 'POST',
-                headers: { 'Content-Type': 'application/json' },
-                body: JSON.stringify({
-                    workspaceId: currentWorkspaceId,
-                    draftUploadId: draftId,
-                    uploadPurpose: 'task-description-draft',
-                }),
+        }
+        catch (error) {
+            console.warn('[Taskforce] Description image upload failed while the draft was being discarded.', error);
+        }
+        try {
+            await resolveDescriptionImageDraft({
+                draftUploadId: draftId,
+                resolution: 'discard',
             });
-            if (!response.ok)
-                throw new Error('Draft upload cleanup was rejected.');
         }
         catch (error) {
             console.warn('[Taskforce] Failed to clean discarded Description image uploads.', error);
         }
-    }, [awaitPendingDescriptionImageUpload, currentWorkspaceId, rotateDescriptionImageDraftId]);
+    }, [awaitPendingDescriptionImageUpload, resolveDescriptionImageDraft, rotateDescriptionImageDraftId]);
     useEffect(() => {
         flushAutoSaveRef.current = flushAutoSave;
     }, [flushAutoSave]);
@@ -3974,6 +4276,11 @@ export function useTaskforce({ config = {}, initialTaskId, initialActivityEntryI
         manualComplexityEnabled,
         checklistDropdownEnabled,
         showTaskCardStatusLabel,
+        showTaskCardDescription,
+        showTaskCardAttachments,
+        showTaskCardChecklistProgress,
+        showTaskCardLatestActivity,
+        tintTaskCardActivityBackground,
         pathSaved,
         settingsSection,
         setupState,
@@ -3983,15 +4290,21 @@ export function useTaskforce({ config = {}, initialTaskId, initialActivityEntryI
         setCurrentTheme,
         handleSaveTheme,
         handleSaveGlobalTheme,
+        handleUseGlobalThemeDefault,
         setKeyShortcut,
         handleJsonBackupEnabledChange,
         handleSaveGlobalJsonBackupEnabled,
+        handleUseGlobalJsonBackupDefault,
         handleSaveGlobalWeekStartsOn,
         handleSaveLocale,
         handleManualComplexityEnabledChange,
         handleChecklistDropdownEnabledChange,
         handleShowTaskCardStatusLabelChange,
-        handleResetProjectToGlobal,
+        handleShowTaskCardDescriptionChange,
+        handleShowTaskCardAttachmentsChange,
+        handleShowTaskCardChecklistProgressChange,
+        handleShowTaskCardLatestActivityChange,
+        handleTintTaskCardActivityBackgroundChange,
         handleSaveSettings,
         initiativeTemplates,
         fetchInitiativeTemplates,
@@ -4091,6 +4404,7 @@ export function useTaskforce({ config = {}, initialTaskId, initialActivityEntryI
     const effectiveConfig = {
         ...mergedConfig,
         cloudEnvironment: runtimeConfigOverride.cloudEnvironment || mergedConfig.cloudEnvironment || '',
+        appGates: runtimeConfigOverride.appGates || mergedConfig.appGates,
         apiBaseUrl: normalizedApiBaseUrl || mergedConfig.apiBaseUrl,
         cloudAuthBaseUrl: normalizedCloudAuthBaseUrl || mergedConfig.cloudAuthBaseUrl,
         wsBaseUrl: effectiveWsBaseUrl || mergedConfig.wsBaseUrl
@@ -4121,6 +4435,11 @@ export function useTaskforce({ config = {}, initialTaskId, initialActivityEntryI
         manualComplexityEnabled,
         checklistDropdownEnabled,
         showTaskCardStatusLabel,
+        showTaskCardDescription,
+        showTaskCardAttachments,
+        showTaskCardChecklistProgress,
+        showTaskCardLatestActivity,
+        tintTaskCardActivityBackground,
         setManualComplexityEnabled,
         mcpHostRoot,
         setMcpHostRoot,

package/dist/hooks/useUiNotice.d.ts

@@ -14,6 +14,10 @@ export declare function useUiNotice(): {
     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;

package/dist/hooks/useUiNotice.js

@@ -35,6 +35,10 @@ export function useUiNotice() {
             ttlMs,
             actionLabel: action?.label,
             onAction: action?.onAction,
+            actionPrimary: action?.primary,
+            secondaryActionLabel: action?.secondaryLabel,
+            onSecondaryAction: action?.onSecondaryAction,
+            dismissible: action?.dismissible,
             ownerKey: action?.ownerKey
         });
         // Actionable notices stay available until the action or explicit