@taskforcehq/taskforce 0.3.328 → 0.3.329

package/dist/core/types.d.ts

@@ -176,6 +176,12 @@ export interface TaskFile {
         jsonBackupEnabled?: boolean;
         manualComplexityEnabled?: boolean;
         checklistDropdownEnabled?: boolean;
+        showTaskCardStatusLabel?: boolean;
+        showTaskCardDescription?: boolean;
+        showTaskCardAttachments?: boolean;
+        showTaskCardChecklistProgress?: boolean;
+        showTaskCardLatestActivity?: boolean;
+        tintTaskCardActivityBackground?: boolean;
         taxonomies?: any[];
     };
 }

package/dist/hooks/sync/useDurableLocalOutboxDrain.d.ts

@@ -6,7 +6,7 @@ export declare function useDurableLocalOutboxDrain(input: {
     workspaceId: string;
     mutationFingerprint: string;
     authorityScope: object;
-    remoteServices: Pick<WorkspaceSyncEngineRemoteServices, 'pullWorkspaceContent' | 'abandonTransferReceipts' | 'buildV2ApplyCompletionGroup'> | null;
+    remoteServices: Pick<WorkspaceSyncEngineRemoteServices, 'pullWorkspaceContent' | 'abandonTransferReceipts' | 'buildIndependentContentApplyCompletionGroup'> | null;
     localServices: Pick<WorkspaceSyncEngineLocalServices, 'applyV2Batch'>;
     isAuthorityCurrent?: (authorityScope: object) => boolean;
     onHydratedEventIds?: (eventIds: string[]) => void;

package/dist/hooks/sync/useDurableTaskCreateMutation.js

@@ -104,7 +104,7 @@ export function useDurableTaskCreateMutation(input) {
             clientRef.current = input.client || createLocalTaskCreateClient();
         const participant = await getParticipant(workspaceId);
         const selected = selectTaskCreateActivationInput(candidate);
-        const participantId = selected
+        const participantId = input.enabled && selected
             ? participant.prepareForDraft(await fingerprintTaskDraft(selected.localTask))
             : participant.participantId;
         let result;

package/dist/hooks/sync/useDurableTaskMetadataMutation.d.ts

@@ -2,6 +2,7 @@ import type { TaskItem } from '../../types.js';
 import { createLocalTaskMetadataClient, type LocalTaskMetadataMutationResult } from '../../sync/v3/localTaskMetadataClient.js';
 export type DurableTaskMetadataMutationAdapter = (taskId: string, patch: Partial<TaskItem>, options?: {
     saveSource?: 'manual' | 'autosave';
+    expectedDetailRevision?: string;
 }) => Promise<LocalTaskMetadataMutationResult | null>;
 type LocalTaskMetadataClient = ReturnType<typeof createLocalTaskMetadataClient>;
 export declare function useDurableTaskMetadataMutation(input: {

package/dist/hooks/sync/useDurableTaskMetadataMutation.js

@@ -17,6 +17,7 @@ export function useDurableTaskMetadataMutation(input) {
             entityId,
             patch: patch,
             ...(options?.saveSource ? { saveSource: options.saveSource } : {}),
+            ...(options?.expectedDetailRevision ? { expectedDetailRevision: options.expectedDetailRevision } : {}),
             isAuthenticated: input.isAuthenticated,
             dispatchEnabled: input.dispatchEnabled,
         });

package/dist/hooks/sync/useDurableTaskStatusMutation.d.ts

@@ -6,6 +6,7 @@ export type DurableTaskStatusMutationAdapter = (taskId: string, payload: {
     assigneeIntent: DurableTaskStatusAssigneeIntent;
     canceledReason: string | null;
     metadataPatch?: Partial<TaskItem>;
+    expectedDetailRevision?: string;
 }) => Promise<LocalTaskStatusMutationResult | null>;
 type LocalTaskStatusClient = ReturnType<typeof createLocalTaskStatusClient>;
 export declare function useDurableTaskStatusMutation(input: {

package/dist/hooks/tasks/taskHttpMutation.js

@@ -44,6 +44,7 @@ export async function isConclusiveTaskHttpResponse(response) {
         'TASK_ATTACHMENT_LINKS_INVALID',
         'TASK_COMMENT_INVALID',
         'TASK_COMMENT_IDENTITY_CONFLICT',
+        'TASK_DETAIL_REVISION_CONFLICT',
     ]).has(code);
 }
 function stableTaskCreateCandidate(candidate) {

package/dist/hooks/tasks/useCloudTaskSearch.d.ts

@@ -0,0 +1,12 @@
+interface UseCloudTaskSearchInput {
+    query: string;
+    runtimeMode: 'local' | 'cloud';
+    workspaceId: string;
+    enabled: boolean;
+    scope: 'active' | 'archive';
+    debounceMs?: number;
+    pageSize?: number;
+    maxMatches?: number;
+}
+export declare function useCloudTaskSearch({ query, runtimeMode, workspaceId, enabled, scope, debounceMs, pageSize, maxMatches, }: UseCloudTaskSearchInput): ReadonlySet<string>;
+export {};

package/dist/hooks/tasks/useCloudTaskSearch.js

@@ -0,0 +1,71 @@
+import { useEffect, useMemo, useRef, useState } from 'react';
+import { normalizeTaskSearchQuery } from '../../utils/taskSearch';
+export function useCloudTaskSearch({ query, runtimeMode, workspaceId, enabled, scope, debounceMs = 250, pageSize = 50, maxMatches = 500, }) {
+    const [matchIds, setMatchIds] = useState(() => new Set());
+    const requestSequenceRef = useRef(0);
+    const normalizedQuery = useMemo(() => normalizeTaskSearchQuery(query).raw, [query]);
+    useEffect(() => {
+        requestSequenceRef.current += 1;
+        const requestSequence = requestSequenceRef.current;
+        if (!enabled || runtimeMode !== 'cloud' || !normalizedQuery || !workspaceId.trim()) {
+            setMatchIds((current) => current.size === 0 ? current : new Set());
+            return;
+        }
+        setMatchIds((current) => current.size === 0 ? current : new Set());
+        const abortController = new AbortController();
+        const timer = window.setTimeout(() => {
+            void (async () => {
+                const collected = new Set();
+                let offset = 0;
+                let scanned = 0;
+                const boundedPageSize = Math.max(1, Math.min(50, Math.trunc(pageSize)));
+                const boundedMaxMatches = Math.max(1, Math.trunc(maxMatches));
+                try {
+                    while (scanned < boundedMaxMatches) {
+                        const limit = Math.min(boundedPageSize, boundedMaxMatches - scanned);
+                        const params = new URLSearchParams({
+                            query: query.trim(),
+                            scope,
+                            limit: String(limit),
+                            offset: String(offset),
+                        });
+                        const response = await fetch(`/api/taskforce/tasks/search?${params.toString()}`, {
+                            signal: abortController.signal,
+                        });
+                        if (!response.ok)
+                            throw new Error(`Task search failed (${response.status}).`);
+                        const body = await response.json();
+                        const matches = body.matches || [];
+                        scanned += matches.length;
+                        for (const match of matches) {
+                            const id = String(match?.id || '').trim();
+                            if (id)
+                                collected.add(id);
+                        }
+                        if (body.pagination?.hasMore !== true)
+                            break;
+                        const nextOffset = Number(body.pagination?.nextOffset);
+                        if (!Number.isInteger(nextOffset) || nextOffset <= offset)
+                            break;
+                        offset = nextOffset;
+                    }
+                    if (!abortController.signal.aborted && requestSequenceRef.current === requestSequence) {
+                        setMatchIds(collected);
+                    }
+                }
+                catch (error) {
+                    if (abortController.signal.aborted || requestSequenceRef.current !== requestSequence)
+                        return;
+                    // Server search augments the existing client matcher. On failure, retain
+                    // the client-visible metadata results instead of blocking the task board.
+                    setMatchIds(new Set());
+                }
+            })();
+        }, Math.max(0, debounceMs));
+        return () => {
+            window.clearTimeout(timer);
+            abortController.abort('superseded');
+        };
+    }, [debounceMs, enabled, maxMatches, normalizedQuery, pageSize, query, runtimeMode, scope, workspaceId]);
+    return matchIds;
+}

package/dist/hooks/tasks/useTaskDescriptionImageDraftRecovery.d.ts

@@ -0,0 +1,16 @@
+export type TaskDescriptionImageDraftResolution = 'promote' | 'discard';
+type DraftRecoveryFetch = (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
+interface UseTaskDescriptionImageDraftRecoveryOptions {
+    fetchImpl?: DraftRecoveryFetch;
+    storage?: Storage | null;
+    now?: () => number;
+}
+export declare const TASK_DESCRIPTION_IMAGE_DRAFT_RECOVERY_STORAGE_KEY = "taskforce.task-description-image-draft-recovery.v1";
+export declare function taskDescriptionImageDraftRetryDelay(attempts: number): number;
+export declare function useTaskDescriptionImageDraftRecovery(workspaceId: string, createdByUserId: string, options?: UseTaskDescriptionImageDraftRecoveryOptions): {
+    resolveDraft: (input: {
+        draftUploadId: string;
+        resolution: TaskDescriptionImageDraftResolution;
+    }) => Promise<void>;
+};
+export {};

package/dist/hooks/tasks/useTaskDescriptionImageDraftRecovery.js

@@ -0,0 +1,197 @@
+import { useCallback, useEffect, useRef } from 'react';
+const defaultFetch = (input, init) => globalThis.fetch(input, init);
+export const TASK_DESCRIPTION_IMAGE_DRAFT_RECOVERY_STORAGE_KEY = 'taskforce.task-description-image-draft-recovery.v1';
+const RETRY_DELAYS_MS = [1_000, 5_000, 15_000, 60_000];
+const MAX_AUTOMATIC_RETRY_ATTEMPTS = 8;
+const DORMANT_RETRY_AT = Number.MAX_SAFE_INTEGER;
+export function taskDescriptionImageDraftRetryDelay(attempts) {
+    const index = Math.max(0, Math.min(RETRY_DELAYS_MS.length - 1, Math.floor(attempts) - 1));
+    return RETRY_DELAYS_MS[index];
+}
+function recordKey(record) {
+    return `${record.workspaceId}\u0000${record.createdByUserId}\u0000${record.draftUploadId}`;
+}
+function isRecoveryRecord(value) {
+    if (!value || typeof value !== 'object')
+        return false;
+    const record = value;
+    return typeof record.workspaceId === 'string'
+        && Boolean(record.workspaceId.trim())
+        && typeof record.createdByUserId === 'string'
+        && Boolean(record.createdByUserId.trim())
+        && typeof record.draftUploadId === 'string'
+        && Boolean(record.draftUploadId.trim())
+        && (record.resolution === 'promote' || record.resolution === 'discard')
+        && Number.isFinite(record.attempts)
+        && Number.isFinite(record.nextAttemptAt)
+        && Number.isFinite(record.createdAt);
+}
+function readRecoveryRecords(storage) {
+    if (!storage)
+        return [];
+    try {
+        const parsed = JSON.parse(storage.getItem(TASK_DESCRIPTION_IMAGE_DRAFT_RECOVERY_STORAGE_KEY) || '[]');
+        if (!Array.isArray(parsed))
+            return [];
+        const records = new Map();
+        parsed.filter(isRecoveryRecord).forEach((record) => {
+            records.set(recordKey(record), record);
+        });
+        return [...records.values()];
+    }
+    catch {
+        return [];
+    }
+}
+function writeRecoveryRecords(storage, records) {
+    if (!storage)
+        return;
+    try {
+        if (records.length === 0) {
+            storage.removeItem(TASK_DESCRIPTION_IMAGE_DRAFT_RECOVERY_STORAGE_KEY);
+            return;
+        }
+        storage.setItem(TASK_DESCRIPTION_IMAGE_DRAFT_RECOVERY_STORAGE_KEY, JSON.stringify(records));
+    }
+    catch {
+        // The request still gets an immediate attempt when browser storage is unavailable.
+    }
+}
+function updateRecoveryRecords(storage, update) {
+    const next = update(readRecoveryRecords(storage));
+    writeRecoveryRecords(storage, next);
+    return next;
+}
+function defaultStorage() {
+    try {
+        return globalThis.localStorage || null;
+    }
+    catch {
+        return null;
+    }
+}
+export function useTaskDescriptionImageDraftRecovery(workspaceId, createdByUserId, options = {}) {
+    const fetchImpl = options.fetchImpl || defaultFetch;
+    const storage = options.storage === undefined ? defaultStorage() : options.storage;
+    const now = options.now || Date.now;
+    const timerRef = useRef(null);
+    const inFlightRef = useRef(new Map());
+    const drainRef = useRef(async () => { });
+    const clearRetryTimer = useCallback(() => {
+        if (timerRef.current === null)
+            return;
+        clearTimeout(timerRef.current);
+        timerRef.current = null;
+    }, []);
+    const scheduleRetry = useCallback(() => {
+        clearRetryTimer();
+        const nextRecord = readRecoveryRecords(storage)
+            .filter((record) => (record.workspaceId === workspaceId
+            && record.createdByUserId === createdByUserId
+            && record.nextAttemptAt < DORMANT_RETRY_AT))
+            .sort((left, right) => left.nextAttemptAt - right.nextAttemptAt)[0];
+        if (!nextRecord)
+            return;
+        const delay = Math.max(0, nextRecord.nextAttemptAt - now());
+        timerRef.current = setTimeout(() => {
+            timerRef.current = null;
+            void drainRef.current(false);
+        }, delay);
+    }, [clearRetryTimer, createdByUserId, now, storage, workspaceId]);
+    const attemptRecovery = useCallback((record) => {
+        const key = recordKey(record);
+        const existing = inFlightRef.current.get(key);
+        if (existing)
+            return existing;
+        const request = (async () => {
+            await Promise.resolve();
+            try {
+                const response = await fetchImpl(`/api/taskforce/context-upload/draft/${record.resolution}`, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({
+                        workspaceId: record.workspaceId,
+                        draftUploadId: record.draftUploadId,
+                        uploadPurpose: 'task-description-draft',
+                    }),
+                });
+                if (!response.ok) {
+                    throw new Error(`Draft upload ${record.resolution} was rejected (${response.status}).`);
+                }
+                updateRecoveryRecords(storage, (records) => (records.filter((candidate) => recordKey(candidate) !== key)));
+            }
+            catch (error) {
+                updateRecoveryRecords(storage, (records) => records.map((candidate) => {
+                    if (recordKey(candidate) !== key)
+                        return candidate;
+                    const attempts = Math.min(Number.MAX_SAFE_INTEGER, candidate.attempts + 1);
+                    return {
+                        ...candidate,
+                        attempts,
+                        nextAttemptAt: attempts >= MAX_AUTOMATIC_RETRY_ATTEMPTS
+                            ? DORMANT_RETRY_AT
+                            : now() + taskDescriptionImageDraftRetryDelay(attempts),
+                    };
+                }));
+                throw error;
+            }
+            finally {
+                inFlightRef.current.delete(key);
+                scheduleRetry();
+            }
+        })();
+        inFlightRef.current.set(key, request);
+        return request;
+    }, [fetchImpl, now, scheduleRetry, storage]);
+    const drain = useCallback(async (force = false) => {
+        const currentTime = now();
+        const dueRecords = readRecoveryRecords(storage).filter((record) => (record.workspaceId === workspaceId
+            && record.createdByUserId === createdByUserId
+            && (force || record.nextAttemptAt <= currentTime)));
+        await Promise.allSettled(dueRecords.map((record) => attemptRecovery(record)));
+        scheduleRetry();
+    }, [attemptRecovery, createdByUserId, now, scheduleRetry, storage, workspaceId]);
+    drainRef.current = drain;
+    useEffect(() => {
+        void drain(true);
+        const retryWhenOnline = () => { void drain(true); };
+        const retryWhenVisible = () => {
+            if (document.visibilityState === 'visible')
+                void drain(true);
+        };
+        const retryAfterStorageChange = (event) => {
+            if (event.key === TASK_DESCRIPTION_IMAGE_DRAFT_RECOVERY_STORAGE_KEY)
+                void drain(false);
+        };
+        window.addEventListener('online', retryWhenOnline);
+        window.addEventListener('storage', retryAfterStorageChange);
+        document.addEventListener('visibilitychange', retryWhenVisible);
+        return () => {
+            clearRetryTimer();
+            window.removeEventListener('online', retryWhenOnline);
+            window.removeEventListener('storage', retryAfterStorageChange);
+            document.removeEventListener('visibilitychange', retryWhenVisible);
+        };
+    }, [clearRetryTimer, drain]);
+    const resolveDraft = useCallback(async (input) => {
+        const draftUploadId = input.draftUploadId.trim();
+        if (!workspaceId || !createdByUserId || !draftUploadId)
+            return;
+        const queuedAt = now();
+        const record = {
+            workspaceId,
+            createdByUserId,
+            draftUploadId,
+            resolution: input.resolution,
+            attempts: 0,
+            nextAttemptAt: queuedAt,
+            createdAt: queuedAt,
+        };
+        updateRecoveryRecords(storage, (records) => [
+            ...records.filter((candidate) => recordKey(candidate) !== recordKey(record)),
+            record,
+        ]);
+        await attemptRecovery(record);
+    }, [attemptRecovery, createdByUserId, now, storage, workspaceId]);
+    return { resolveDraft };
+}

package/dist/hooks/tasks/useTaskEditorNavigation.d.ts

@@ -1,5 +1,12 @@
 import type { AttachmentItem, CategoryConfig, ChecklistItem, Comment, TaskAssignee, TaskItem, TaskStatus, TaxonomyDefinition, WorkstreamItem } from '../../types';
 type TaskforceTab = 'add' | 'tasks' | 'settings';
+type ApplyTaskOptions = {
+    preserveReturnTrail?: boolean;
+    adoptAsBaseline?: boolean;
+};
+type LoadTaskOptions = ApplyTaskOptions & {
+    shouldApply?: () => boolean;
+};
 interface UseTaskEditorNavigationInput {
     activeCategories: CategoryConfig[];
     activeTypes: Array<{
@@ -10,6 +17,7 @@ interface UseTaskEditorNavigationInput {
     attachments: Array<string | AttachmentItem>;
     checklistItems: ChecklistItem[];
     comments: Comment[];
+    cancelTaskDetailLoad?: () => void;
     description: string;
     editingTaskId: string | null;
     flushPendingAutoSave: () => Promise<boolean>;
@@ -17,7 +25,12 @@ interface UseTaskEditorNavigationInput {
     getPreferredCategoryValue: (categories: CategoryConfig[]) => string;
     getTitleDraft?: () => string;
     lastUsedCategory: string;
+    loadTaskDetail?: (task: TaskItem, options?: {
+        shouldCommit?: () => boolean;
+        force?: boolean;
+    }) => Promise<TaskItem | null>;
     newCommentText: string;
+    onTaskApplied?: (task: TaskItem) => void;
     relationshipTasks: TaskItem[];
     workstreams: WorkstreamItem[];
     showArchive: boolean;
@@ -56,9 +69,9 @@ export declare function useTaskEditorNavigation(input: UseTaskEditorNavigationIn
     resetForm: () => void;
     resolveTaskIdInput: (value: string) => TaskItem | null;
     resolveWorkstreamIdInput: (value: string) => WorkstreamItem | null;
-    handleEdit: (task: TaskItem, options?: {
-        preserveReturnTrail?: boolean;
-    }) => void;
+    handleEdit: (task: TaskItem, options?: ApplyTaskOptions) => void;
+    refreshTaskDetail: (task: TaskItem, options?: LoadTaskOptions) => Promise<TaskItem | null>;
+    applyTaskToEditor: (task: TaskItem, options?: ApplyTaskOptions) => void;
     handleOpenTaskById: (taskId: string) => void;
     returnToPreviousTask: () => boolean;
     clearReturnToParentTask: () => void;

package/dist/hooks/tasks/useTaskEditorNavigation.js

@@ -1,17 +1,26 @@
-import { useCallback } from 'react';
+import { useCallback, useRef } from 'react';
 import { DEFAULT_TYPE_VALUE } from '../../shared/taxonomyDefaults.js';
 import { getTaskReferenceLabel, parseTaskReference } from '../../utils/taskReferences';
 import { formatWorkstreamReference, parseWorkstreamReference } from '../../utils/planningReferences';
 import { buildDefaultFormTaxonomies } from '../../utils/taxonomyFormDefaults.js';
 export function useTaskEditorNavigation(input) {
-    const { activeCategories, activeTypes, activeTab, attachments, checklistItems, comments, description, editingTaskId, flushPendingAutoSave, getDescriptionDraft, getPreferredCategoryValue, getTitleDraft, lastUsedCategory, newCommentText, relationshipTasks, workstreams, showArchive, taxonomies, setActiveTab, setAssignee, setAttachments, setAttachmentsDirty, setCategory, setChecklistItems, setComments, setComplexity, setDescription, setDueDate, setEditingTaskId, setError, setFormTaxonomies, setIsOpen, setNewCommentText, setPendingNavigation, setWorkstreamInput, setPriority, setScheduledDate, setShowArchive, setStatus, setTaskReturnTrail, setTitle, setType, setUnsavedModalOpen, taskReturnTrail, title, } = input;
+    const { activeCategories, activeTypes, activeTab, attachments, checklistItems, comments, cancelTaskDetailLoad, description, editingTaskId, flushPendingAutoSave, getDescriptionDraft, getPreferredCategoryValue, getTitleDraft, lastUsedCategory, loadTaskDetail, newCommentText, onTaskApplied, relationshipTasks, workstreams, showArchive, taxonomies, setActiveTab, setAssignee, setAttachments, setAttachmentsDirty, setCategory, setChecklistItems, setComments, setComplexity, setDescription, setDueDate, setEditingTaskId, setError, setFormTaxonomies, setIsOpen, setNewCommentText, setPendingNavigation, setWorkstreamInput, setPriority, setScheduledDate, setShowArchive, setStatus, setTaskReturnTrail, setTitle, setType, setUnsavedModalOpen, taskReturnTrail, title, } = input;
+    const editRequestSequenceRef = useRef(0);
+    const invalidatePendingEdit = useCallback(() => {
+        editRequestSequenceRef.current += 1;
+        cancelTaskDetailLoad?.();
+    }, [cancelTaskDetailLoad]);
     const getPreferredTypeValue = useCallback(() => {
         return activeTypes.find((entry) => String(entry.value || '').trim().length > 0)?.value || DEFAULT_TYPE_VALUE;
     }, [activeTypes]);
     const handleNavigation = useCallback(async (action) => {
+        const navigate = () => {
+            invalidatePendingEdit();
+            action();
+        };
         if (editingTaskId) {
             if (await flushPendingAutoSave()) {
-                action();
+                navigate();
             }
             return;
         }
@@ -22,10 +31,10 @@ export function useTaskEditorNavigation(input) {
             comments.length > 0 ||
             attachments.length > 0;
         if (!hasChanges) {
-            action();
+            navigate();
             return;
         }
-        setPendingNavigation(() => action);
+        setPendingNavigation(() => navigate);
         setUnsavedModalOpen(true);
     }, [
         attachments,
@@ -36,15 +45,18 @@ export function useTaskEditorNavigation(input) {
         getDescriptionDraft,
         getTitleDraft,
         checklistItems,
+        invalidatePendingEdit,
         newCommentText,
         setPendingNavigation,
         setUnsavedModalOpen,
         title,
     ]);
     const handleClose = useCallback(() => {
+        invalidatePendingEdit();
         setIsOpen(false);
-    }, [setIsOpen]);
+    }, [invalidatePendingEdit, setIsOpen]);
     const resetForm = useCallback(() => {
+        invalidatePendingEdit();
         setEditingTaskId(null);
         setTitle('');
         setDescription('');
@@ -76,6 +88,7 @@ export function useTaskEditorNavigation(input) {
         activeCategories,
         getPreferredCategoryValue,
         getPreferredTypeValue,
+        invalidatePendingEdit,
         lastUsedCategory,
         setAssignee,
         setAttachments,
@@ -134,7 +147,7 @@ export function useTaskEditorNavigation(input) {
             return exactTitle;
         return null;
     }, [workstreams]);
-    const handleEdit = useCallback((task, options) => {
+    const applyTaskToEditor = useCallback((task, options) => {
         if (!options?.preserveReturnTrail) {
             setTaskReturnTrail([]);
         }
@@ -157,6 +170,8 @@ export function useTaskEditorNavigation(input) {
         setAttachments(task.attachments || []);
         setAttachmentsDirty(false);
         setActiveTab('add');
+        if (options?.adoptAsBaseline !== false)
+            onTaskApplied?.(task);
     }, [
         activeCategories,
         getPreferredCategoryValue,
@@ -179,20 +194,62 @@ export function useTaskEditorNavigation(input) {
         setTaskReturnTrail,
         setTitle,
         setType,
+        onTaskApplied,
         workstreams
     ]);
+    const loadAndApplyTask = useCallback(async (task, options) => {
+        const requestSequence = editRequestSequenceRef.current + 1;
+        editRequestSequenceRef.current = requestSequence;
+        if (!loadTaskDetail) {
+            cancelTaskDetailLoad?.();
+            applyTaskToEditor(task, { preserveReturnTrail: options?.preserveReturnTrail });
+            return task;
+        }
+        if (!task.isSummary) {
+            cancelTaskDetailLoad?.();
+            const detail = options?.shouldApply
+                ? await loadTaskDetail(task, { shouldCommit: options.shouldApply })
+                : await loadTaskDetail(task);
+            if (editRequestSequenceRef.current === requestSequence) {
+                const taskToApply = detail || task;
+                applyTaskToEditor(taskToApply, { preserveReturnTrail: options?.preserveReturnTrail });
+                return taskToApply;
+            }
+            return null;
+        }
+        const detail = options?.shouldApply
+            ? await loadTaskDetail(task, { shouldCommit: options.shouldApply })
+            : await loadTaskDetail(task);
+        if (detail
+            && editRequestSequenceRef.current === requestSequence) {
+            applyTaskToEditor(detail, { preserveReturnTrail: options?.preserveReturnTrail });
+            return detail;
+        }
+        return null;
+    }, [applyTaskToEditor, cancelTaskDetailLoad, loadTaskDetail]);
+    const handleEdit = useCallback((task, options) => {
+        void loadAndApplyTask(task, options);
+    }, [loadAndApplyTask]);
+    const refreshTaskDetail = useCallback((task, options) => loadAndApplyTask(task, options), [loadAndApplyTask]);
     const handleOpenTaskById = useCallback((taskId) => {
         const target = relationshipTasks.find((task) => task.id === taskId);
         if (!target)
             return;
+        const openTarget = () => {
+            if (activeTab === 'add' && editingTaskId && editingTaskId !== target.id) {
+                setTaskReturnTrail((prev) => prev[prev.length - 1] === editingTaskId ? prev : [...prev, editingTaskId]);
+            }
+            if (target.isArchived && !showArchive) {
+                setShowArchive(true);
+            }
+            handleEdit(target, { preserveReturnTrail: true });
+        };
         if (activeTab === 'add' && editingTaskId && editingTaskId !== target.id) {
-            setTaskReturnTrail((prev) => prev[prev.length - 1] === editingTaskId ? prev : [...prev, editingTaskId]);
-        }
-        if (target.isArchived && !showArchive) {
-            setShowArchive(true);
+            void handleNavigation(openTarget);
+            return;
         }
-        handleEdit(target, { preserveReturnTrail: true });
-    }, [activeTab, editingTaskId, handleEdit, relationshipTasks, setShowArchive, setTaskReturnTrail, showArchive]);
+        openTarget();
+    }, [activeTab, editingTaskId, handleEdit, handleNavigation, relationshipTasks, setShowArchive, setTaskReturnTrail, showArchive]);
     const returnToPreviousTask = useCallback(() => {
         if (activeTab !== 'add' || !editingTaskId || taskReturnTrail.length === 0)
             return false;
@@ -224,6 +281,8 @@ export function useTaskEditorNavigation(input) {
         resolveTaskIdInput,
         resolveWorkstreamIdInput,
         handleEdit,
+        refreshTaskDetail,
+        applyTaskToEditor,
         handleOpenTaskById,
         returnToPreviousTask,
         clearReturnToParentTask

package/dist/hooks/tasks/useTaskFormActions.d.ts

@@ -1,6 +1,7 @@
 import type { AttachmentItem, CategoryConfig, ChecklistItem, TaskAssignee, TaskItem, TaskStatus, TaxonomyDefinition, WorkstreamItem } from '../../types';
 import type { DurableTaskCreateMutationAdapter } from '../sync/useDurableTaskCreateMutation.js';
 import { createCloudTaskHttpMutationClient } from './taskHttpMutation.js';
+import type { TaskEditorDraft } from '../../utils/taskEditorReconciliation.js';
 interface UseTaskFormActionsInput {
     activeCategories: CategoryConfig[];
     activeTab: 'add' | 'tasks' | 'settings';
@@ -20,6 +21,8 @@ interface UseTaskFormActionsInput {
     taskHttpMutationClient?: ReturnType<typeof createCloudTaskHttpMutationClient>;
     updateTask?: (taskId: string, updates: Partial<TaskItem>) => Promise<boolean | void>;
     editingTaskId: string | null;
+    editorBaselineDraft?: TaskEditorDraft | null;
+    revisionConflict?: boolean;
     fetchTasks: (isSilent?: boolean) => Promise<void>;
     formTaxonomies: Record<string, string | number | string[] | number[]>;
     getAttachmentsDraft?: () => Array<string | AttachmentItem>;
@@ -55,6 +58,9 @@ interface UseTaskFormActionsInput {
 export type TaskAutoSaveState = 'idle' | 'saving' | 'saved' | 'error';
 export declare function useTaskFormActions(input: UseTaskFormActionsInput): {
     autoSaveState: TaskAutoSaveState;
+    hasUnsavedChanges: boolean;
+    hasUnsavedChangesNow: () => boolean;
+    hasPendingAutoSave: boolean;
     flushAutoSave: () => Promise<boolean>;
     scheduleWarningPrompt: {
         dueDate: string;