@taskforcehq/taskforce 0.3.329 → 0.3.330

package/dist/hooks/useTaskData.d.ts

@@ -1,3 +1,28 @@
+/**
+ * useTaskData
+ *
+ * Manages the task fetch lifecycle, recently-changed-task highlighting,
+ * and merge/coalesce helpers. Task and archive state arrays live in
+ * useTaskforce.ts (because they must be passed to useSyncOrchestrator),
+ * but all fetch and mutation helpers are encapsulated here.
+ *
+ * === SECTION MAP ===
+ *   === SECTION: Recently Changed ===       — recentlyChangedTaskIds, markRecentlyChangedTasks, timer cleanup
+ *   === SECTION: Fetch Functions ===        — fetchTasks, fetchArchive, refreshTaskCollections, refreshTaskCollectionsFromInvalidation
+ *   === SECTION: Revision Tracking ===      — getTaskRevisionKey, taskRevisionMapRef, hasFetchedTasksRef
+ *   === SECTION: Merge Helper ===           — mergeTaskFromServer
+ *
+ * Key return values:
+ *   - fetchTasks(isSilent?, options?) — refresh the active task list
+ *   - fetchArchive(isSilent?, options?) — refresh the archive
+ *   - refreshTaskCollections(options?) — refresh both in parallel
+ *   - refreshTaskCollectionsFromInvalidation() — scoped task collection refresh
+ *   - mergeTaskFromServer(task) — merge a single server response into both collections
+ *   - markRecentlyChangedTasks(ids) — flag task IDs for highlight animation
+ *   - recentlyChangedTaskIds — task IDs that changed in the last 2s
+ *   - getTaskRevisionKey(task) — stable revision string for change detection
+ */
+import { type MutableRefObject } from 'react';
 import type { TaskItem } from '../types';
 interface UseTaskDataProps {
     tasks: TaskItem[];
@@ -14,8 +39,13 @@ interface UseTaskDataProps {
     authRequiredForApi: boolean;
     setError?: (value: string) => void;
     setLoading?: (value: boolean) => void;
+    pendingTaskMetadataOverlaysRef?: MutableRefObject<Map<string, PendingTaskMetadataOverlay>>;
 }
-export declare function useTaskData({ tasks, archivedTasks, setTasks, setArchivedTasks, setLoadingTasks, getCurrentWorkspaceId, workspaceResetKey, shouldDeferProtectedApiCalls, shouldBlockProtectedApiCalls, handleUnauthorized, authRequiredForApi, setError, setLoading }: UseTaskDataProps): {
+export interface PendingTaskMetadataOverlay {
+    patch: Partial<TaskItem>;
+    observedUpdatedAt: string | null;
+}
+export declare function useTaskData({ tasks, archivedTasks, setTasks, setArchivedTasks, setLoadingTasks, getCurrentWorkspaceId, workspaceResetKey, shouldDeferProtectedApiCalls, shouldBlockProtectedApiCalls, handleUnauthorized, authRequiredForApi, setError, setLoading, pendingTaskMetadataOverlaysRef, }: UseTaskDataProps): {
     tasksRef: import("react").RefObject<TaskItem[]>;
     archivedTasksRef: import("react").RefObject<TaskItem[]>;
     taskDetails: TaskItem[];

package/dist/hooks/useTaskData.js

@@ -25,7 +25,8 @@
 import { useState, useEffect, useCallback, useRef } from 'react';
 import { getTaskContentRevision, mergeNormalizedTaskIntoCollections, normalizeTaskFromApi, reconcileTaskCollection, toTaskCollectionSummary } from '../utils/taskNormalization.js';
 import { resolveTaskReferenceId } from '../utils/taskReferences.js';
-export function useTaskData({ tasks, archivedTasks, setTasks, setArchivedTasks, setLoadingTasks, getCurrentWorkspaceId, workspaceResetKey, shouldDeferProtectedApiCalls, shouldBlockProtectedApiCalls, handleUnauthorized, authRequiredForApi, setError, setLoading }) {
+import { canonicalWorkspaceSyncJson } from '../sync/v3/canonicalWorkspaceSyncJson.js';
+export function useTaskData({ tasks, archivedTasks, setTasks, setArchivedTasks, setLoadingTasks, getCurrentWorkspaceId, workspaceResetKey, shouldDeferProtectedApiCalls, shouldBlockProtectedApiCalls, handleUnauthorized, authRequiredForApi, setError, setLoading, pendingTaskMetadataOverlaysRef, }) {
     // === SECTION: Revision Tracking ===
     const taskRevisionMapRef = useRef(new Map());
     const hasFetchedTasksRef = useRef(false);
@@ -58,6 +59,26 @@ export function useTaskData({ tasks, archivedTasks, setTasks, setArchivedTasks,
     const getTaskRevisionKey = useCallback((task) => {
         return getTaskContentRevision(task);
     }, []);
+    const preservePendingTaskMetadata = useCallback((task) => {
+        const pending = pendingTaskMetadataOverlaysRef?.current.get(task.id);
+        if (!pending)
+            return task;
+        const patchMatches = Object.entries(pending.patch).every(([key, value]) => {
+            const candidate = task[key];
+            return candidate === undefined || value === undefined
+                ? candidate === value
+                : canonicalWorkspaceSyncJson(candidate) === canonicalWorkspaceSyncJson(value);
+        });
+        const candidateUpdatedAt = Date.parse(String(task.updatedAt || ''));
+        const observedUpdatedAt = Date.parse(String(pending.observedUpdatedAt || ''));
+        if (patchMatches || (Number.isFinite(candidateUpdatedAt)
+            && Number.isFinite(observedUpdatedAt)
+            && candidateUpdatedAt > observedUpdatedAt)) {
+            pendingTaskMetadataOverlaysRef?.current.delete(task.id);
+            return task;
+        }
+        return { ...task, ...pending.patch };
+    }, [pendingTaskMetadataOverlaysRef]);
     const isExpectedAbortFailure = useCallback((error, signal) => {
         if (!signal.aborted)
             return false;
@@ -192,7 +213,7 @@ export function useTaskData({ tasks, archivedTasks, setTasks, setArchivedTasks,
             }
             if (res.ok) {
                 const data = await res.json();
-                const sanitized = (data.tasks || []).map((t) => normalizeTaskFromApi(t));
+                const sanitized = (data.tasks || []).map((t) => (preservePendingTaskMetadata(normalizeTaskFromApi(t))));
                 const liveWorkspaceId = String(getCurrentWorkspaceId() || '').trim();
                 if (liveWorkspaceId !== requestWorkspaceId) {
                     return;
@@ -251,7 +272,8 @@ export function useTaskData({ tasks, archivedTasks, setTasks, setArchivedTasks,
         authRequiredForApi,
         shouldDeferProtectedApiCalls,
         shouldBlockProtectedApiCalls,
-        reconcileTaskDetailCache
+        reconcileTaskDetailCache,
+        preservePendingTaskMetadata,
     ]);
     const fetchArchive = useCallback(async (isSilent = false, options) => {
         const ignoreAuthGuard = options?.ignoreAuthGuard === true;
@@ -272,7 +294,7 @@ export function useTaskData({ tasks, archivedTasks, setTasks, setArchivedTasks,
                     return false;
                 }
                 const sanitized = (data.archived || []).map((t) => ({
-                    ...normalizeTaskFromApi(t),
+                    ...preservePendingTaskMetadata(normalizeTaskFromApi(t)),
                     isArchived: true
                 }));
                 reconcileTaskDetailCache(sanitized, true);
@@ -299,7 +321,7 @@ export function useTaskData({ tasks, archivedTasks, setTasks, setArchivedTasks,
                     setLoadingTasks(false);
             }
         }
-    }, [getCurrentWorkspaceId, isExpectedAbortFailure, reconcileTaskDetailCache, setArchivedTasks, setLoadingTasks, shouldDeferProtectedApiCalls, shouldBlockProtectedApiCalls]);
+    }, [getCurrentWorkspaceId, isExpectedAbortFailure, preservePendingTaskMetadata, reconcileTaskDetailCache, setArchivedTasks, setLoadingTasks, shouldDeferProtectedApiCalls, shouldBlockProtectedApiCalls]);
     const loadTaskDetail = useCallback(async (task, options) => {
         const force = options?.force === true;
         if (!force && !task.isSummary) {
@@ -429,7 +451,7 @@ export function useTaskData({ tasks, archivedTasks, setTasks, setArchivedTasks,
     }, [refreshTaskCollections]);
     // === SECTION: Merge Helper ===
     const mergeTaskFromServer = useCallback((task) => {
-        const normalized = normalizeTaskFromApi(task);
+        const normalized = preservePendingTaskMetadata(normalizeTaskFromApi(task));
         const existingSummary = [...tasksRef.current, ...archivedTasksRef.current]
             .find((candidate) => candidate.id === normalized.id);
         const collectionSummary = normalized.isSummary
@@ -467,7 +489,7 @@ export function useTaskData({ tasks, archivedTasks, setTasks, setArchivedTasks,
             setTasks(merged.tasks);
         if (archivedTasksChanged)
             setArchivedTasks(merged.archivedTasks);
-    }, [getTaskSummaryRevision, publishTaskDetailCache, setTasks, setArchivedTasks]);
+    }, [getTaskSummaryRevision, preservePendingTaskMetadata, publishTaskDetailCache, setTasks, setArchivedTasks]);
     return {
         // Stable refs (for use inside closures)
         tasksRef,

package/dist/hooks/useTaskMutations.d.ts

@@ -8,6 +8,7 @@ import type { DurableTaskDeleteMutationAdapter } from './sync/useDurableTaskDele
 import type { DurableTaskRestoreMutationAdapter } from './sync/useDurableTaskRestoreMutation.js';
 import type { TaskRestoreDestination } from '../shared/taskRestoreDestination.js';
 import type { DurableTaskTargetStatus } from '../core/TaskDurableStatusMutationService.js';
+import type { PendingTaskMetadataOverlay } from './useTaskData.js';
 import { createCloudTaskHttpMutationClient } from './tasks/taskHttpMutation.js';
 export interface UseTaskMutationsProps {
     tasks: TaskItem[];
@@ -47,6 +48,7 @@ export interface UseTaskMutationsProps {
     taskHttpMutationClient?: ReturnType<typeof createCloudTaskHttpMutationClient>;
     onTaskRevisionConflict?: (taskId: string, currentDetailRevision: string | null) => TaskRevisionConflictResolution | void | Promise<TaskRevisionConflictResolution | void>;
     onTaskMutationAccepted?: (task: TaskItem) => void;
+    pendingTaskMetadataOverlaysRef?: MutableRefObject<Map<string, PendingTaskMetadataOverlay>>;
 }
 export interface TaskRevisionConflictResolution {
     handled: boolean;
@@ -66,7 +68,7 @@ export interface DeletedTaskRestoreBatchResult {
     succeeded: DeletedTaskRecord[];
     failed: DeletedTaskRestoreFailure[];
 }
-export declare function useTaskMutations({ tasks, archivedTasks, editingTaskId, editingTaskDetailRevision, setTasks, setArchivedTasks, setDeletedTasks, setError, resetForm, setActiveTab, fetchTasks, fetchArchive, fetchDeletedTasks, mergeTaskFromServer, pushNotice, cloudAuthConfigured, runtimeMode, isAuthenticated, workspaceCloudSyncEnabled, buildWorkspaceSyncSignature, pushWorkspaceChangesToCloud, workspacePendingSignatureRef, workspaceDeletedTaskIdsRef, workspaceDeletedTaskWatermarksRef, mutateTaskMetadata, mutateTaskStatus, mutateTaskLifecycle, mutateTaskDelete, mutateTaskRestore, durableTaskMetadataActivationEnabled, durableTaskStatusActivationEnabled, durableTaskDeleteActivationEnabled, durableTaskHttpRootActivationEnabled, workspaceId, taskHttpMutationClient, onTaskRevisionConflict, onTaskMutationAccepted, }: UseTaskMutationsProps): {
+export declare function useTaskMutations({ tasks, archivedTasks, editingTaskId, editingTaskDetailRevision, setTasks, setArchivedTasks, setDeletedTasks, setError, resetForm, setActiveTab, fetchTasks, fetchArchive, fetchDeletedTasks, mergeTaskFromServer, pushNotice, cloudAuthConfigured, runtimeMode, isAuthenticated, workspaceCloudSyncEnabled, buildWorkspaceSyncSignature, pushWorkspaceChangesToCloud, workspacePendingSignatureRef, workspaceDeletedTaskIdsRef, workspaceDeletedTaskWatermarksRef, mutateTaskMetadata, mutateTaskStatus, mutateTaskLifecycle, mutateTaskDelete, mutateTaskRestore, durableTaskMetadataActivationEnabled, durableTaskStatusActivationEnabled, durableTaskDeleteActivationEnabled, durableTaskHttpRootActivationEnabled, workspaceId, taskHttpMutationClient, onTaskRevisionConflict, onTaskMutationAccepted, pendingTaskMetadataOverlaysRef, }: UseTaskMutationsProps): {
     copiedId: string | null;
     handleDelete: (id: string, archive?: boolean, options?: {
         skipConfirm?: boolean;

package/dist/hooks/useTaskMutations.js

@@ -41,7 +41,7 @@ function taskHttpObservedPrecondition(task, taskId) {
         isArchived: task?.isArchived === true,
     };
 }
-export function useTaskMutations({ tasks, archivedTasks, editingTaskId, editingTaskDetailRevision = null, setTasks, setArchivedTasks, setDeletedTasks, setError, resetForm, setActiveTab, fetchTasks, fetchArchive, fetchDeletedTasks, mergeTaskFromServer, pushNotice, cloudAuthConfigured, runtimeMode, isAuthenticated, workspaceCloudSyncEnabled, buildWorkspaceSyncSignature, pushWorkspaceChangesToCloud, workspacePendingSignatureRef, workspaceDeletedTaskIdsRef, workspaceDeletedTaskWatermarksRef, mutateTaskMetadata, mutateTaskStatus, mutateTaskLifecycle, mutateTaskDelete, mutateTaskRestore, durableTaskMetadataActivationEnabled = false, durableTaskStatusActivationEnabled = false, durableTaskDeleteActivationEnabled = false, durableTaskHttpRootActivationEnabled = false, workspaceId = 'default', taskHttpMutationClient, onTaskRevisionConflict, onTaskMutationAccepted, }) {
+export function useTaskMutations({ tasks, archivedTasks, editingTaskId, editingTaskDetailRevision = null, setTasks, setArchivedTasks, setDeletedTasks, setError, resetForm, setActiveTab, fetchTasks, fetchArchive, fetchDeletedTasks, mergeTaskFromServer, pushNotice, cloudAuthConfigured, runtimeMode, isAuthenticated, workspaceCloudSyncEnabled, buildWorkspaceSyncSignature, pushWorkspaceChangesToCloud, workspacePendingSignatureRef, workspaceDeletedTaskIdsRef, workspaceDeletedTaskWatermarksRef, mutateTaskMetadata, mutateTaskStatus, mutateTaskLifecycle, mutateTaskDelete, mutateTaskRestore, durableTaskMetadataActivationEnabled = false, durableTaskStatusActivationEnabled = false, durableTaskDeleteActivationEnabled = false, durableTaskHttpRootActivationEnabled = false, workspaceId = 'default', taskHttpMutationClient, onTaskRevisionConflict, onTaskMutationAccepted, pendingTaskMetadataOverlaysRef, }) {
     const authoritativeTaskSnapshotsRef = useRef(new Map());
     useEffect(() => {
         if (typeof window === 'undefined')
@@ -703,6 +703,18 @@ export function useTaskMutations({ tasks, archivedTasks, editingTaskId, editingT
         let hasLegacyCarriers = Object.keys(legacyCarrierPatch).length > 0;
         let durableMetadataHandled = false;
         if (hasDurableMetadata && mutateTaskMetadata) {
+            const pendingOverlay = {
+                patch: durableMetadataPatch,
+                observedUpdatedAt: observedTask?.updatedAt || null,
+            };
+            pendingTaskMetadataOverlaysRef?.current.set(id, pendingOverlay);
+            const clearPendingOverlay = () => {
+                if (pendingTaskMetadataOverlaysRef?.current.get(id) === pendingOverlay) {
+                    pendingTaskMetadataOverlaysRef.current.delete(id);
+                }
+            };
+            const ownsPendingOverlay = () => (!pendingTaskMetadataOverlaysRef
+                || pendingTaskMetadataOverlaysRef.current.get(id) === pendingOverlay);
             try {
                 const initialMutationOptions = {
                     ...(saveSource ? { saveSource } : {}),
@@ -711,6 +723,8 @@ export function useTaskMutations({ tasks, archivedTasks, editingTaskId, editingT
                 let durableResult = Object.keys(initialMutationOptions).length > 0
                     ? await mutateTaskMetadata(id, durableMetadataPatch, initialMutationOptions)
                     : await mutateTaskMetadata(id, durableMetadataPatch);
+                if (!ownsPendingOverlay())
+                    return false;
                 if (durableResult && durableResult.state !== 'disabled') {
                     if ((durableResult.state === 'rejected' || durableResult.state === 'failed')
                         && durableResult.errorCode === 'TASK_DETAIL_REVISION_CONFLICT') {
@@ -719,6 +733,8 @@ export function useTaskMutations({ tasks, archivedTasks, editingTaskId, editingT
                         setTasks((currentTasks) => rollbackTargetTaskPatch(currentTasks, previousTask, id, updates));
                         setArchivedTasks((currentTasks) => rollbackTargetTaskPatch(currentTasks, previousTask, id, updates));
                         const resolution = await onTaskRevisionConflict?.(id, null);
+                        if (!ownsPendingOverlay())
+                            return false;
                         if (resolution?.retryDetailRevision) {
                             const reconciledPatch = resolution.retryPatch;
                             const retryMetadataPatch = Object.fromEntries(Object.entries(durableMetadataPatch).map(([key, value]) => [
@@ -727,10 +743,13 @@ export function useTaskMutations({ tasks, archivedTasks, editingTaskId, editingT
                                     ? reconciledPatch[key]
                                     : value,
                             ]));
+                            pendingOverlay.patch = retryMetadataPatch;
                             durableResult = await mutateTaskMetadata(id, retryMetadataPatch, {
                                 ...(saveSource ? { saveSource } : {}),
                                 expectedDetailRevision: resolution.retryDetailRevision,
                             });
+                            if (!ownsPendingOverlay())
+                                return false;
                             if (durableResult
                                 && (durableResult.state === 'rejected' || durableResult.state === 'failed')
                                 && durableResult.errorCode === 'TASK_DETAIL_REVISION_CONFLICT') {
@@ -757,6 +776,7 @@ export function useTaskMutations({ tasks, archivedTasks, editingTaskId, editingT
                         return false;
                     }
                     if (durableResult.state === 'rejected' || durableResult.state === 'failed') {
+                        clearPendingOverlay();
                         const previousTask = previousTasks.find((task) => task.id === id)
                             || previousArchivedTasks.find((task) => task.id === id);
                         setTasks((currentTasks) => rollbackTargetTaskPatch(currentTasks, previousTask, id, updates));
@@ -771,7 +791,15 @@ export function useTaskMutations({ tasks, archivedTasks, editingTaskId, editingT
                         return false;
                     }
                     durableMetadataHandled = true;
-                    if ('task' in durableResult && durableResult.task) {
+                    if ('task' in durableResult
+                        && durableResult.task?.updatedAt
+                        && pendingTaskMetadataOverlaysRef?.current.get(id) === pendingOverlay) {
+                        pendingOverlay.observedUpdatedAt = durableResult.task.updatedAt;
+                    }
+                    if ('task' in durableResult
+                        && durableResult.task
+                        && (!pendingTaskMetadataOverlaysRef
+                            || pendingTaskMetadataOverlaysRef.current.get(id) === pendingOverlay)) {
                         mergeTaskFromServer(durableResult.task);
                         onTaskMutationAccepted?.(durableResult.task);
                     }
@@ -807,18 +835,24 @@ export function useTaskMutations({ tasks, archivedTasks, editingTaskId, editingT
                     if (!hasLegacyCarriers)
                         return true;
                 }
-                else if (durableTaskMetadataActivationEnabled) {
-                    const previousTask = previousTasks.find((task) => task.id === id)
-                        || previousArchivedTasks.find((task) => task.id === id);
-                    setTasks((currentTasks) => rollbackTargetTaskPatch(currentTasks, previousTask, id, updates));
-                    setArchivedTasks((currentTasks) => rollbackTargetTaskPatch(currentTasks, previousTask, id, updates));
-                    const message = 'Task was not saved because durable metadata capture was unavailable.';
-                    setError(message);
-                    pushNotice(message, 'error');
-                    return false;
+                else {
+                    clearPendingOverlay();
+                    if (durableTaskMetadataActivationEnabled) {
+                        const previousTask = previousTasks.find((task) => task.id === id)
+                            || previousArchivedTasks.find((task) => task.id === id);
+                        setTasks((currentTasks) => rollbackTargetTaskPatch(currentTasks, previousTask, id, updates));
+                        setArchivedTasks((currentTasks) => rollbackTargetTaskPatch(currentTasks, previousTask, id, updates));
+                        const message = 'Task was not saved because durable metadata capture was unavailable.';
+                        setError(message);
+                        pushNotice(message, 'error');
+                        return false;
+                    }
                 }
             }
             catch (error) {
+                if (!ownsPendingOverlay())
+                    return false;
+                clearPendingOverlay();
                 console.error('Durable task metadata update failed before a conclusive result.', error);
                 if (hasLegacyCarriers) {
                     const previousTask = previousTasks.find((task) => task.id === id)
@@ -926,7 +960,7 @@ export function useTaskMutations({ tasks, archivedTasks, editingTaskId, editingT
             setArchivedTasks((currentTasks) => rollbackTargetTaskPatch(currentTasks, previousTask, id, legacyCarrierPatch));
             return false;
         }
-    }, [tasks, archivedTasks, editingTaskDetailRevision, editingTaskId, pushNotice, mergeTaskFromServer, mutateTaskMetadata, onTaskMutationAccepted, onTaskRevisionConflict, queueWorkspaceSyncFromAuthoritativeTaskState, handleSetStatus, durableTaskMetadataActivationEnabled, durableTaskStatusActivationEnabled, fetchCloudTaskRootPatch]);
+    }, [tasks, archivedTasks, editingTaskDetailRevision, editingTaskId, pushNotice, mergeTaskFromServer, mutateTaskMetadata, onTaskMutationAccepted, onTaskRevisionConflict, pendingTaskMetadataOverlaysRef, queueWorkspaceSyncFromAuthoritativeTaskState, handleSetStatus, durableTaskMetadataActivationEnabled, durableTaskStatusActivationEnabled, fetchCloudTaskRootPatch]);
     const handleToggleComplete = async (task) => {
         const newStatus = task.status === 'done' ? 'task' : 'done';
         await handleSetStatus(task, newStatus);

package/dist/hooks/useTaskforce.d.ts

@@ -205,6 +205,8 @@ export declare function useTaskforce({ config, initialTaskId, initialActivityEnt
         phase: import("./sync/useLocalSyncCoordinatorSnapshot").LocalSyncCoordinatorSnapshotPhase;
         snapshot: import("../sync/coordinator/localSyncCoordinatorBrowserClient").LocalSyncCoordinatorStatusResponse | null;
         errorMessage: string | null;
+        activeCommandType: import("../sync/coordinator/localSyncCoordinatorTypes").LocalSyncCoordinatorCommandType | null;
+        activePriorityCommandType: import("../sync/coordinator/localSyncCoordinatorTypes").LocalSyncCoordinatorCommandType | null;
     } | null;
     transferLocalCoordinatorOwnership: (targetMode: "server" | "browser-gateway") => Promise<boolean>;
     retryUserGlobalSettingsSync: () => Promise<void>;

package/dist/hooks/useTaskforce.js

@@ -395,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) {
@@ -883,6 +886,7 @@ export function useTaskforce({ config = {}, initialTaskId, initialActivityEntryI
     }, [AUTH_REQUIRED_ERROR, runtimeMode]);
     // === SECTION: Task Data ===
     // Delegated to useTaskData — see src/hooks/useTaskData.ts
+    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,
@@ -896,7 +900,8 @@ export function useTaskforce({ config = {}, initialTaskId, initialActivityEntryI
         handleUnauthorized,
         authRequiredForApi,
         setError,
-        setLoading
+        setLoading,
+        pendingTaskMetadataOverlaysRef,
     });
     useEffect(() => {
         if (workspaceTransitionEpoch === 0)
@@ -918,6 +923,7 @@ export function useTaskforce({ config = {}, initialTaskId, initialActivityEntryI
         deletedHydrationRequestRef.current = null;
         setTasks([]);
         setArchivedTasks([]);
+        pendingTaskMetadataOverlaysRef.current.clear();
         setInitiatives([]);
         setWorkstreams([]);
         setPlanningBootstrapTaskSummaries([]);
@@ -1363,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,
@@ -2769,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',
@@ -2826,6 +2833,7 @@ export function useTaskforce({ config = {}, initialTaskId, initialActivityEntryI
     }, [
         abortWorkspaceScopedRequests,
         authRequiredForApi,
+        clearLocalCoordinatorCredential,
         clearPersistedWorkspaceId,
         commitCurrentWorkspaceId,
         resolveCloudAuthUrl,
@@ -3999,6 +4007,7 @@ export function useTaskforce({ config = {}, initialTaskId, initialActivityEntryI
         workspaceId: currentWorkspaceId,
         onTaskRevisionConflict: handleTaskRevisionConflict,
         onTaskMutationAccepted: handleTaskMutationAccepted,
+        pendingTaskMetadataOverlaysRef,
     });
     const { resolveDraft: resolveDescriptionImageDraft } = useTaskDescriptionImageDraftRecovery(currentWorkspaceId, authUserId);
     const promoteDescriptionImageDraft = useCallback(async () => {

package/dist/mcp/clientRegistry.d.ts

@@ -1,11 +1,11 @@
 import type { AiProfileSurfaceType } from '../shared/aiProfileSurfaceType.js';
+import type { ProductLogoKey } from '../shared/productLogoKeys.js';
 export declare const MCP_CLIENT_IDS: readonly ["general", "cursor", "cline", "vscode", "kiro", "windsurf", "antigravity", "openclaw", "codex", "grok", "claude-code", "gemini-cli", "grok-chat", "gemini-chat", "mistral-chat", "perplexity-chat", "claude-chat", "chatgpt-desktop"];
 export type McpClientId = typeof MCP_CLIENT_IDS[number];
-export type McpClientLogoKey = Exclude<McpClientId, 'general' | 'openclaw'>;
 export interface McpClientRegistryEntry {
     id: McpClientId;
     label: string;
-    logoKey?: McpClientLogoKey;
+    logoKey?: ProductLogoKey;
     surfaceHint?: AiProfileSurfaceType;
     generatedOption?: boolean;
     signatureColor?: string;

package/dist/mcp/clientRegistry.js

@@ -36,7 +36,7 @@ export const MCP_CLIENT_REGISTRY = {
     openclaw: { id: 'openclaw', label: 'OpenClaw', surfaceHint: 'agent', generatedOption: true },
     vscode: { id: 'vscode', label: 'VS Code / Copilot', logoKey: 'vscode', surfaceHint: 'ide', generatedOption: true, signatureColor: '#256ee4' },
     windsurf: { id: 'windsurf', label: 'Windsurf', logoKey: 'windsurf', surfaceHint: 'ide', generatedOption: true, signatureColor: '#189587' },
-    'chatgpt-desktop': { id: 'chatgpt-desktop', label: 'ChatGPT Desktop', logoKey: 'chatgpt-desktop', surfaceHint: 'chat_app', signatureColor: '#10a37f' },
+    'chatgpt-desktop': { id: 'chatgpt-desktop', label: 'ChatGPT Desktop', logoKey: 'chatgpt', surfaceHint: 'chat_app', signatureColor: '#10a37f' },
 };
 export function parseMcpClientId(value) {
     const normalized = String(value || '').trim().toLowerCase();

package/dist/mcp/documentAssetRegistrar.js

@@ -460,14 +460,14 @@ export function registerDocumentAssetTools(registerTool, executeTool) {
         },
     }));
     register('review_document', (context) => ({
-        description: context.describeTool('Create or reuse a review session for one document and append review comments. Use this for plan and document reviews.'),
+        description: context.describeTool('Add document review comments, reply to a root thread, or resolve/reopen a thread. Reply/thread modes require sessionId and are exclusive.'),
         inputSchema: {
             properties: {
-                documentId: stringProperty('Document asset id or document reference such as D-123.'),
-                sessionId: stringProperty('Optional existing review session id.'),
-                title: stringProperty('Optional review session title when a new session is created.'),
-                prompt: stringProperty('Review instructions or focus areas.'),
-                comments: arrayProperty('Explicit review comments to add. When omitted, prompt is saved as a single review comment.', {
+                documentId: stringProperty('D-123 or asset id.'),
+                sessionId: stringProperty('Existing review session id.'),
+                title: stringProperty('New-session title.'),
+                prompt: stringProperty('Single comment.'),
+                comments: arrayProperty('Comments; prompt can supply one.', {
                     type: 'object',
                     properties: {
                         body: { type: 'string' },
@@ -475,6 +475,9 @@ export function registerDocumentAssetTools(registerTool, executeTool) {
                     },
                     required: ['body'],
                 }),
+                parentCommentId: stringProperty('Root id for an unanchored reply.'),
+                threadCommentId: stringProperty('Root id to resolve or reopen.'),
+                threadStatus: stringProperty('Thread status.', ['open', 'resolved']),
             },
         },
     }));

package/dist/mcp/durableTaskMutationRouter.d.ts

@@ -6,6 +6,7 @@ import { type LocalTaskStatusOutboxCore } from '../sync/v3/localTaskStatusOutbox
 import { type DurableTaskLifecycleServiceCore } from '../sync/v3/taskLifecycleMutationService.js';
 import { type DurableTaskStatusServiceCore } from '../sync/v3/taskStatusMutationService.js';
 import { type DurableTaskWorkflowServiceCore } from '../sync/v3/taskWorkflowMutationService.js';
+import type { TaskStatusReviewHandoff } from '../sync/v3/workflowAssignmentSync.js';
 export type McpTaskStatusActivationCapability = {
     taskStatusMcpActivation: boolean;
 };
@@ -29,7 +30,9 @@ export type DurableTaskMutationRouter = {
     enabled: boolean;
     setStatus(args: {
         taskId: string;
-        payload: DurableTaskStatusMutationPayload;
+        payload: DurableTaskStatusMutationPayload & {
+            reviewHandoff?: TaskStatusReviewHandoff;
+        };
         actorRef: string;
     }): DurableMcpTaskMutationResult;
     mutateLifecycle(args: {

package/dist/mcp/durableTaskMutationRouter.js

@@ -7,6 +7,7 @@ import { runDurableTaskLifecycleMutation, } from '../sync/v3/taskLifecycleMutati
 import { runDurableTaskStatusMutation, } from '../sync/v3/taskStatusMutationService.js';
 import { runDurableTaskWorkflowMutation, } from '../sync/v3/taskWorkflowMutationService.js';
 import { readDurableOperationReplay } from '../sync/v3/durableOperationReplay.js';
+import { areWorkflowRuntimeMutationsFenced, resolveWorkflowRuntimeDurableTransportCapability, } from '../sync/v3/durableWorkflowRuntimeMutationRouter.js';
 const OPERATION_LEASE_MS = 30_000;
 function isEnabled(value) {
     return /^(1|true|on|yes)$/i.test(String(value || '').trim());
@@ -70,6 +71,13 @@ export function createDurableTaskMutationRouter(input) {
     const identityStore = new LocalSyncIdentityStore(input.core.getDatabaseAdapter());
     const createOperationId = input.createOperationId || defaultOperationId;
     const now = input.now || (() => new Date());
+    const workflowRuntimeJournalEnabled = resolveWorkflowRuntimeDurableTransportCapability({
+        runtimeMode: input.runtimeMode,
+        surface: 'mcp',
+        env: input.env,
+    });
+    const rejectWorkflowRuntimeActivation = workflowRuntimeJournalEnabled
+        && areWorkflowRuntimeMutationsFenced(input.env);
     const operationContext = (enabled, mutationKind, taskId) => {
         if (!enabled)
             throw new DurableTaskMutationRouterDisabledError();
@@ -156,6 +164,8 @@ export function createDurableTaskMutationRouter(input) {
             const result = runDurableTaskStatusMutation({
                 ...cloudCommon(taskId, actorRef, context, revisions),
                 payload: args.payload,
+                includeWorkflowRuntimeJournal: workflowRuntimeJournalEnabled,
+                rejectWorkflowRuntimeActivation,
             });
             if (result.state === 'in_progress')
                 throw new DurableTaskMutationRouterInProgressError(result.retryAt);

package/dist/mcp/durableTaskRelationshipMutationRouter.js

@@ -53,6 +53,10 @@ export function createDurableTaskRelationshipMutationRouter(input) {
                     || persisted.mutationKind !== args.mutationKind)) {
                     throw new Error('Operation identity is already assigned to another task relationship mutation.');
                 }
+                if (persisted)
+                    store.assertOutboxOperationIdentity(persisted, {
+                        domain: 'task-relationship', entityId: canonical.id, mutationKind: args.mutationKind,
+                    });
                 if (!persisted && args.mutationKind === 'link' && current && !current.deletedAt) {
                     return { state: 'noop', route: 'no-change', operationId: null, relationship: current, outcome: 'existing' };
                 }

package/dist/mcp/httpProtocolRouting.d.ts

@@ -0,0 +1,10 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import { type McpServerFactory } from '@modelcontextprotocol/server';
+export declare function isModernMcpHttpRequest(req: IncomingMessage, parsedBody: unknown): Promise<boolean>;
+export declare function handleModernMcpHttpRequest(input: {
+    req: IncomingMessage;
+    res: ServerResponse;
+    parsedBody: unknown;
+    factory: McpServerFactory;
+    onerror?: (error: Error) => void;
+}): Promise<void>;

package/dist/mcp/httpProtocolRouting.js

@@ -0,0 +1,19 @@
+import { toNodeHandler, toWebRequest } from '@modelcontextprotocol/node';
+import { createMcpHandler, isLegacyRequest, } from '@modelcontextprotocol/server';
+export async function isModernMcpHttpRequest(req, parsedBody) {
+    const request = await toWebRequest(req, parsedBody);
+    return !(await isLegacyRequest(request, parsedBody));
+}
+export async function handleModernMcpHttpRequest(input) {
+    const handler = createMcpHandler(input.factory, {
+        legacy: 'reject',
+        responseMode: 'auto',
+        onerror: input.onerror,
+    });
+    try {
+        await toNodeHandler(handler, { onerror: input.onerror })(input.req, input.res, input.parsedBody);
+    }
+    finally {
+        await handler.close();
+    }
+}

package/dist/mcp/localCliHealth.d.ts

@@ -1,5 +1,5 @@
-import { Client } from '@modelcontextprotocol/sdk/client/index.js';
-import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
+import { Client } from '@modelcontextprotocol/client';
+import { StdioClientTransport } from '@modelcontextprotocol/client/stdio';
 export type LocalCliHealthState = 'healthy' | 'version-mismatch' | 'unusable';
 export interface LocalCliHealthResult {
     state: LocalCliHealthState;

package/dist/mcp/localCliHealth.js

@@ -3,8 +3,8 @@ import { constants as fsConstants, accessSync, readFileSync, statSync } from 'no
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { promisify } from 'node:util';
-import { Client } from '@modelcontextprotocol/sdk/client/index.js';
-import { getDefaultEnvironment, StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
+import { Client } from '@modelcontextprotocol/client';
+import { getDefaultEnvironment, StdioClientTransport } from '@modelcontextprotocol/client/stdio';
 const execFileAsync = promisify(execFile);
 const DEFAULT_TIMEOUT_MS = 5_000;
 function stripAnsi(value) {

package/dist/mcp/localServiceProxy.d.ts

@@ -15,6 +15,7 @@ export interface LocalServiceProxyOptions {
     requestTimeoutMs?: number;
     onFatal?: (error: Error) => void;
     logError?: (message: string) => void;
+    sleep?: (delayMs: number) => Promise<void>;
 }
 export interface LocalServiceProxyRuntime {
     close(): Promise<void>;