@taskforcehq/taskforce 0.3.327 → 0.3.329

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,
@@ -619,6 +639,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 +691,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 +883,7 @@ 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 { tasksRef, archivedTasksRef, taskDetails, staleTaskDetailRevisions, recentlyChangedTaskIds, markRecentlyChangedTasks, fetchTasks: fetchTasksBase, fetchArchive: fetchArchiveBase, loadTaskDetail, cancelTaskDetailLoad, refreshTaskCollections: refreshTaskCollectionsBase, refreshTaskCollectionsFromInvalidation: refreshTaskCollectionsFromInvalidationBase, mergeTaskFromServer, getTaskRevisionKey } = useTaskData({
         tasks,
         archivedTasks,
         setTasks,
@@ -863,7 +894,9 @@ export function useTaskforce({ config = {}, initialTaskId, initialActivityEntryI
         shouldDeferProtectedApiCalls,
         shouldBlockProtectedApiCalls,
         handleUnauthorized,
-        authRequiredForApi
+        authRequiredForApi,
+        setError,
+        setLoading
     });
     useEffect(() => {
         if (workspaceTransitionEpoch === 0)
@@ -1445,7 +1478,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;
@@ -1494,7 +1535,46 @@ export function useTaskforce({ config = {}, initialTaskId, initialActivityEntryI
     const [activeWorkspaceModule, setActiveWorkspaceModuleState] = useState('tasks');
     const [descriptionFocused, setDescriptionFocused] = useState(false);
     const [isCapturingScreenshot, setIsCapturingScreenshot] = useState(false);
-    const [attachments, setAttachments] = useState([]);
+    const attachmentsDraftRef = useRef([]);
+    const [attachments, setAttachmentsState] = useState([]);
+    const setAttachments = useCallback((next) => {
+        const nextAttachments = typeof next === 'function'
+            ? next(attachmentsDraftRef.current)
+            : next;
+        attachmentsDraftRef.current = nextAttachments;
+        setAttachmentsState(nextAttachments);
+    }, []);
+    const getAttachmentsDraft = useCallback(() => [...attachmentsDraftRef.current], []);
+    const pendingDescriptionImageUploadRef = useRef(null);
+    const [descriptionImageUploadPending, setDescriptionImageUploadPending] = useState(false);
+    const createDescriptionImageDraftId = useCallback(() => (`task-description-${globalThis.crypto?.randomUUID?.() || `${Date.now()}-${Math.random().toString(16).slice(2)}`}`), []);
+    const descriptionImageDraftIdRef = useRef(createDescriptionImageDraftId());
+    const [descriptionImageDraftId, setDescriptionImageDraftId] = useState(descriptionImageDraftIdRef.current);
+    const rotateDescriptionImageDraftId = useCallback(() => {
+        const nextDraftId = createDescriptionImageDraftId();
+        descriptionImageDraftIdRef.current = nextDraftId;
+        setDescriptionImageDraftId(nextDraftId);
+    }, [createDescriptionImageDraftId]);
+    const registerDescriptionImageUpload = useCallback((upload) => {
+        pendingDescriptionImageUploadRef.current = upload;
+        setDescriptionImageUploadPending(true);
+        void upload.then(() => {
+            if (pendingDescriptionImageUploadRef.current !== upload)
+                return;
+            pendingDescriptionImageUploadRef.current = null;
+            setDescriptionImageUploadPending(false);
+        }, () => {
+            if (pendingDescriptionImageUploadRef.current !== upload)
+                return;
+            pendingDescriptionImageUploadRef.current = null;
+            setDescriptionImageUploadPending(false);
+        });
+    }, []);
+    const awaitPendingDescriptionImageUpload = useCallback(async () => {
+        const upload = pendingDescriptionImageUploadRef.current;
+        if (upload)
+            await upload;
+    }, []);
     const [attachmentsDirty, setAttachmentsDirty] = useState(false);
     const dataVersionRef = useRef(null);
     const ambiguousRealtimeConfirmationTimerRef = useRef(null);
@@ -1510,7 +1590,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,
@@ -1527,7 +1607,12 @@ export function useTaskforce({ config = {}, initialTaskId, initialActivityEntryI
         setLocale,
         setManualComplexityEnabled,
         setChecklistDropdownEnabled,
-        setShowTaskCardStatusLabel
+        setShowTaskCardStatusLabel,
+        setShowTaskCardDescription,
+        setShowTaskCardAttachments,
+        setShowTaskCardChecklistProgress,
+        setShowTaskCardLatestActivity,
+        setTintTaskCardActivityBackground
     });
     useEffect(() => {
         if (runtimeMode !== 'cloud')
@@ -1728,6 +1813,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();
@@ -2804,6 +2919,24 @@ export function useTaskforce({ config = {}, initialTaskId, initialActivityEntryI
         setInitiatives((current) => upsertEntityById(current, data));
         return data;
     }, [fetchPlanningEntities, runInitiativeMutation]);
+    const updatePlanningIdentity = useCallback(async (entityType, id, patch) => {
+        const res = await runInitiativeMutation(`/api/taskforce/${entityType}/${encodeURIComponent(id)}/identity`, {
+            method: 'PATCH',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(patch),
+        });
+        const data = await res.json().catch(() => ({}));
+        if (!res.ok)
+            throw new Error(data?.error || `Failed to update ${entityType} identity (${res.status})`);
+        if (entityType === 'initiative') {
+            setInitiatives((current) => upsertEntityById(current, data));
+        }
+        else {
+            setWorkstreams((current) => upsertEntityById(current, data));
+        }
+        void fetchPlanningEntities();
+        return data;
+    }, [fetchPlanningEntities, runInitiativeMutation]);
     const refreshPlanningEntitiesInBackground = useCallback(() => {
         void fetchPlanningEntities();
     }, [fetchPlanningEntities]);
@@ -3244,13 +3377,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,
@@ -3406,13 +3534,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(),
@@ -3420,7 +3560,9 @@ export function useTaskforce({ config = {}, initialTaskId, initialActivityEntryI
         getPreferredCategoryValue,
         getTitleDraft,
         lastUsedCategory,
+        loadTaskDetail,
         newCommentText,
+        onTaskApplied: adoptTaskEditorBaseline,
         relationshipTasks,
         workstreams,
         showArchive,
@@ -3453,6 +3595,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)
@@ -3748,10 +3927,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,
@@ -3783,8 +3997,19 @@ export function useTaskforce({ config = {}, initialTaskId, initialActivityEntryI
         durableTaskDeleteActivationEnabled: taskDeleteActivationEnabled,
         durableTaskHttpRootActivationEnabled: runtimeConfigOverride.syncV3TaskCloudHttpRootActivation,
         workspaceId: currentWorkspaceId,
+        onTaskRevisionConflict: handleTaskRevisionConflict,
+        onTaskMutationAccepted: handleTaskMutationAccepted,
     });
-    const { autoSaveState, flushAutoSave, scheduleWarningPrompt, handleSubmit, confirmScheduleWarning, cancelScheduleWarning, handleAddComment } = useTaskFormActions({
+    const { resolveDraft: resolveDescriptionImageDraft } = useTaskDescriptionImageDraftRecovery(currentWorkspaceId, authUserId);
+    const promoteDescriptionImageDraft = useCallback(async () => {
+        const draftId = descriptionImageDraftIdRef.current;
+        rotateDescriptionImageDraftId();
+        await resolveDescriptionImageDraft({
+            draftUploadId: draftId,
+            resolution: 'promote',
+        });
+    }, [resolveDescriptionImageDraft, rotateDescriptionImageDraftId]);
+    const { autoSaveState, hasUnsavedChanges, flushAutoSave, scheduleWarningPrompt, handleSubmit, confirmScheduleWarning, cancelScheduleWarning, handleAddComment } = useTaskFormActions({
         activeCategories,
         activeTab,
         apiEndpoint,
@@ -3802,11 +4027,16 @@ 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,
         getDescriptionDraft,
         getPreferredCategoryValue,
         getTitleDraft,
+        awaitPendingDescriptionImageUpload,
+        onTaskCreateAccepted: promoteDescriptionImageDraft,
         mergeTaskFromServer,
         onTaskCreated: handleEdit,
         workstreamInput,
@@ -3831,6 +4061,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();
+        }
+        catch (error) {
+            console.warn('[Taskforce] Description image upload failed while the draft was being discarded.', error);
+        }
+        try {
+            await resolveDescriptionImageDraft({
+                draftUploadId: draftId,
+                resolution: 'discard',
+            });
+        }
+        catch (error) {
+            console.warn('[Taskforce] Failed to clean discarded Description image uploads.', error);
+        }
+    }, [awaitPendingDescriptionImageUpload, resolveDescriptionImageDraft, rotateDescriptionImageDraftId]);
     useEffect(() => {
         flushAutoSaveRef.current = flushAutoSave;
     }, [flushAutoSave]);
@@ -3877,6 +4267,11 @@ export function useTaskforce({ config = {}, initialTaskId, initialActivityEntryI
         manualComplexityEnabled,
         checklistDropdownEnabled,
         showTaskCardStatusLabel,
+        showTaskCardDescription,
+        showTaskCardAttachments,
+        showTaskCardChecklistProgress,
+        showTaskCardLatestActivity,
+        tintTaskCardActivityBackground,
         pathSaved,
         settingsSection,
         setupState,
@@ -3886,15 +4281,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,
@@ -3994,6 +4395,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
@@ -4024,6 +4426,11 @@ export function useTaskforce({ config = {}, initialTaskId, initialActivityEntryI
         manualComplexityEnabled,
         checklistDropdownEnabled,
         showTaskCardStatusLabel,
+        showTaskCardDescription,
+        showTaskCardAttachments,
+        showTaskCardChecklistProgress,
+        showTaskCardLatestActivity,
+        tintTaskCardActivityBackground,
         setManualComplexityEnabled,
         mcpHostRoot,
         setMcpHostRoot,
@@ -4181,6 +4588,7 @@ export function useTaskforce({ config = {}, initialTaskId, initialActivityEntryI
         fetchAssigneeOptions,
         createInitiative,
         updateInitiative,
+        updatePlanningIdentity,
         archiveInitiative,
         unarchiveInitiative,
         createWorkstream,
@@ -4244,6 +4652,9 @@ export function useTaskforce({ config = {}, initialTaskId, initialActivityEntryI
         setAttachments,
         attachmentsDirty,
         setAttachmentsDirty,
+        descriptionImageUploadPending,
+        descriptionImageDraftId,
+        registerDescriptionImageUpload,
         descriptionFocused,
         setDescriptionFocused,
         showMarkdownHelp,
@@ -4253,6 +4664,7 @@ export function useTaskforce({ config = {}, initialTaskId, initialActivityEntryI
         // Form Actions
         handleSubmit,
         resetForm,
+        discardDescriptionImageDraft,
         handleAddComment,
         handleSetWorkstreamForCurrentTask,
         handleOpenTaskById,

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;