@taskforcehq/taskforce 0.3.326 → 0.3.328

package/dist/hooks/useTaskforce.js

@@ -13,8 +13,7 @@
  *   === SECTION: Auth State ===             Line ~426  — isAuthenticated, authBlocked, userId, beta access
  *   === SECTION: Bootstrap State ===        Line ~442  — bootstrapPhase, setupState, runtimeCapabilities
  *   === SECTION: Fetch Intercept ===        Line ~490  — window.fetch patch for cloud API routing
- *   === SECTION: Workflow Templates ===     Line ~577  — fetchWorkflows, fetchInitiativeTemplates
- *   === SECTION: Export State ===           Line ~678  — exportEnvironment, exportWorkflowsPath
+ *   === SECTION: Initiative Templates ===   Line ~577  — fetchInitiativeTemplates
  *   === SECTION: Task State ===             Line ~1065 — tasks, archivedTasks, editingTaskId
  *   === SECTION: Filter & Sort State ===    Line ~1394 — searchQuery, filterCategories, sortBy, sortOrder
  *   === SECTION: UI State ===               Line ~1469 — uiStateReady, persisted UI preferences
@@ -40,20 +39,20 @@ import { getSupportedLocales, initializeLocale } from '../localization';
 import { WORKSPACE_BOOTSTRAP_SCOPE, isReservedWorkspaceId, resolveWorkspaceSelectionScopeForRuntime, resolveWorkspaceUiStateScopeForRuntime } from '../utils/workspaceIdentity';
 import { resolveRuntimeModeContract } from '../shared/runtimeContract';
 import { DEFAULT_TYPE_VALUE } from '../shared/taxonomyDefaults.js';
-import { cloneDefaultWorkflowDefinitions } from '../shared/workflowDefaults.js';
 import { resolveClientDeploymentConfig } from '../config/clientDeployment';
 import { resolveTaskforceMcpBaseUrlFromBaseUrl } from '../config/cloudEnvironment';
 import { buildBootstrapTraceId, withBootstrapTraceHeader } from '../utils/bootstrapTrace';
+import { buildTaskforceCredentialLoginPayload } from '../utils/authLogin';
 import { createDefaultAssigneeOptions } from '../utils/assignees';
 import { persistLocalMutationActorUserId, readLocalMutationActorUserId } from '../utils/taskforceApiClient';
+import { resolveWorkspaceSyncV3CombinedWireContract, } from '../sync/v3/workspaceSyncV3CombinedWireContract.js';
 import { useSyncOrchestrator } from './useSyncOrchestrator';
 import { useRealtimeSync } from './useRealtimeSync';
 import { useUiNotice } from './ui/useUiNotice';
-import { useResourceExport } from './ui/useResourceExport';
 import { useSettingsModel } from './ui/useSettingsModel';
 import { useSettingsPersistence } from './ui/useSettingsPersistence';
 import { useSettingsTaxonomyManagement } from './ui/useSettingsTaxonomyManagement';
-import { useWorkflowTemplates } from './ui/useWorkflowTemplates';
+import { useInitiativeTemplates } from './ui/useInitiativeTemplates';
 import { useZenMode } from './ui/useZenMode';
 import { useTaskData } from './useTaskData';
 import { useCurrentTaskRelations } from './tasks/useCurrentTaskRelations';
@@ -62,13 +61,25 @@ import { useTaskFilters } from './tasks/useTaskFilters';
 import { useTaskFormActions } from './tasks/useTaskFormActions';
 import { useTaskRelationships } from './tasks/useTaskRelationships';
 import { useTaskActions } from './tasks/useTaskActions';
-import { areFilterTaxonomySignaturesEqual, buildFilterTaxonomySignature, clearPersistedWorkspaceId, logBootstrapDebug, persistRemoteUiState, readPersistedAppUiState, readPersistedWorkspaceId, writePersistedAppUiState, writePersistedWorkspaceId } from './workspace/workspaceLocalState';
+import { clearPersistedWorkspaceId, logBootstrapDebug, readPersistedWorkspaceId, writePersistedWorkspaceId } from './workspace/workspaceLocalState';
 import { useTaskforceApiRouting } from './workspace/useTaskforceApiRouting';
 import { useTaskforceAuthBootstrap } from './auth/useTaskforceAuthBootstrap';
 import { deriveAuthGuardPolicy } from './auth/useAuthGuardPolicy';
 import { useTaskforceWorkspaceBootstrap } from './workspace/useTaskforceWorkspaceBootstrap';
+import { usePersistedAppUiState } from './workspace/usePersistedAppUiState';
 import { useDataVersionRefresh } from './sync/useDataVersionRefresh';
+import { useDurableTaskMetadataMutation } from './sync/useDurableTaskMetadataMutation';
+import { useDurableTaskCreateMutation } from './sync/useDurableTaskCreateMutation';
+import { useDurableTaskStatusMutation } from './sync/useDurableTaskStatusMutation';
+import { useDurableTaskLifecycleMutation } from './sync/useDurableTaskLifecycleMutation';
+import { useDurableTaskDeleteMutation } from './sync/useDurableTaskDeleteMutation';
+import { useDurableTaskRestoreMutation } from './sync/useDurableTaskRestoreMutation';
 import { BOOTSTRAP_REQUEST_TIMEOUT_MS } from './bootstrapTimeouts';
+import { TASKFORCE_TASKS_MUTATED_EVENT } from '../utils/taskEvents';
+import { createTaskInvalidationScope, mergeTaskInvalidationScopes, resolveTaskInvalidationHighlightIds, resolveRealtimeTaskInvalidation, } from '../utils/taskInvalidation';
+import { createCloudWorkstreamHttpMutationClient, fetchWorkstreamHttpMutation, isConclusiveWorkstreamHttpResponse, selectCreatedWorkstreamAfterRefresh, } from './workstreams/workstreamHttpMutation';
+import { dispatchTaskforceWorkspaceResourcesInvalidated } from '../utils/workspaceResourceEvents';
+import { dispatchTaskforceAuthSessionChanged } from '../utils/authSessionEvents';
 function upsertEntityById(items, nextItem) {
     const existingIndex = items.findIndex((item) => item.id === nextItem.id);
     if (existingIndex === -1) {
@@ -76,6 +87,17 @@ function upsertEntityById(items, nextItem) {
     }
     return items.map((item, index) => (index === existingIndex ? nextItem : item));
 }
+function createInitialPlanningLoadState() {
+    return {
+        status: 'loading',
+        error: null,
+        isRefreshing: false,
+        collections: {
+            initiatives: 'loading',
+            workstreams: 'loading',
+        },
+    };
+}
 const ENV_DEPLOYMENT = resolveClientDeploymentConfig(import.meta.env);
 const DEFAULT_CLOUD_APP_ORIGIN = (() => {
     const configuredBase = ENV_DEPLOYMENT.baseUrl;
@@ -120,7 +142,7 @@ function createBootstrapTimeoutError(timeoutMs) {
     timeoutError.name = 'BootstrapTimeoutError';
     return timeoutError;
 }
-function sanitizePlanningBootstrapPayload(input) {
+export function sanitizePlanningBootstrapPayload(input) {
     const payload = input && typeof input === 'object' ? input : {};
     const initiatives = Array.isArray(payload.initiatives)
         ? payload.initiatives.filter((item) => Boolean(item && typeof item === 'object' && typeof item.id === 'string'))
@@ -147,8 +169,15 @@ function sanitizePlanningBootstrapPayload(input) {
                         .map((task) => ({
                         id: String(task.id || '').trim(),
                         referenceNumber: typeof task.referenceNumber === 'number' ? task.referenceNumber : null,
+                        localReferenceNumber: typeof task.localReferenceNumber === 'number' ? task.localReferenceNumber : null,
+                        referenceLabel: typeof task.referenceLabel === 'string'
+                            ? task.referenceLabel.trim() || undefined
+                            : undefined,
                         title: String(task.title || '').trim() || 'Untitled Task',
                         status: typeof task.status === 'string' ? task.status : null,
+                        assignee: typeof task.assignee === 'string' ? task.assignee : null,
+                        attachmentCount: Math.max(0, Number(task.attachmentCount) || 0),
+                        isArchived: Boolean(task.isArchived),
                     })),
                 }];
         })
@@ -159,7 +188,7 @@ function sanitizePlanningBootstrapPayload(input) {
         workstreamTaskSummaries,
     };
 }
-export function useTaskforce({ config = {}, initialTaskId, onTaskCountChange, onClose }) {
+export function useTaskforce({ config = {}, initialTaskId, initialActivityEntryId, requestedWorkspaceId, onTaskCountChange, onClose }) {
     const mergedConfig = { ...DEFAULT_CONFIG, ...config };
     const { categories, types, apiEndpoint, apiBaseUrl, cloudAuthBaseUrl, cloudMcpBaseUrl, wsBaseUrl, shortcut: configShortcut } = mergedConfig;
     const runtimeHost = typeof window !== 'undefined'
@@ -178,7 +207,18 @@ export function useTaskforce({ config = {}, initialTaskId, onTaskCountChange, on
         cloudAuthViaLocalProxy: false,
         authSource: '',
         workspaceMode: '',
-        workspaceSwitchingEnabled: null
+        workspaceSwitchingEnabled: null,
+        syncV3TaskMetadataActivation: false,
+        syncV3TaskCreateActivation: false,
+        syncV3TaskStatusActivation: false,
+        syncV3TaskDeleteActivation: false,
+        syncV3TaskCloudHttpRootActivation: false,
+        syncV3LocalOutboxDispatch: false,
+        localCoordinatorBrowserAuthorityGate: false,
+        syncV3InitiativeFeedActivation: undefined,
+        syncV3CombinedFeedRouteAvailable: undefined,
+        syncV3CombinedFeedActivation: undefined,
+        syncV3CombinedFeedCoverage: undefined
     });
     const [runtimeConfigReady, setRuntimeConfigReady] = useState(false);
     const normalizeBaseUrl = useCallback((value) => {
@@ -194,7 +234,8 @@ export function useTaskforce({ config = {}, initialTaskId, onTaskCountChange, on
             try {
                 const res = await fetch('/api/taskforce/auth/runtime-config', {
                     method: 'GET',
-                    credentials: 'include'
+                    credentials: 'include',
+                    cache: 'no-store',
                 });
                 if (!res.ok)
                     return;
@@ -209,6 +250,7 @@ export function useTaskforce({ config = {}, initialTaskId, onTaskCountChange, on
                     ? workspaceModeRaw
                     : (runtimeModeHint === 'cloud' ? 'multi-cloud' : 'single-local');
                 setRuntimeMode(runtimeModeHint);
+                const combinedFeedWire = resolveWorkspaceSyncV3CombinedWireContract(cfg.syncV3?.combinedFeed?.coverage || {});
                 setRuntimeConfigOverride({
                     cloudEnvironment: typeof cfg.cloudEnvironment === 'string'
                         ? String(cfg.cloudEnvironment).trim().toLowerCase()
@@ -224,7 +266,24 @@ export function useTaskforce({ config = {}, initialTaskId, onTaskCountChange, on
                     workspaceMode,
                     workspaceSwitchingEnabled: typeof cfg.workspaceSwitchingEnabled === 'boolean'
                         ? Boolean(cfg.workspaceSwitchingEnabled)
-                        : (workspaceMode === 'multi-cloud')
+                        : (workspaceMode === 'multi-cloud'),
+                    syncV3TaskMetadataActivation: cfg.syncV3?.taskMetadataActivation === true,
+                    syncV3TaskCreateActivation: cfg.syncV3?.taskCreateActivation === true,
+                    syncV3TaskStatusActivation: cfg.syncV3?.taskStatusActivation === true,
+                    syncV3TaskDeleteActivation: cfg.syncV3?.taskDeleteActivation === true,
+                    syncV3TaskCloudHttpRootActivation: cfg.syncV3?.taskCloudHttpRootActivation === true,
+                    syncV3LocalOutboxDispatch: cfg.syncV3?.localOutboxDispatch === true,
+                    localCoordinatorBrowserAuthorityGate: cfg.syncV3?.localCoordinatorBrowserAuthorityGate === true,
+                    syncV3InitiativeFeedActivation: typeof cfg.syncV3?.initiativeFeedActivation === 'boolean'
+                        ? cfg.syncV3.initiativeFeedActivation
+                        : undefined,
+                    syncV3CombinedFeedRouteAvailable: typeof cfg.syncV3?.combinedFeed?.routeAvailable === 'boolean'
+                        ? cfg.syncV3.combinedFeed.routeAvailable
+                        : undefined,
+                    syncV3CombinedFeedActivation: typeof cfg.syncV3?.combinedFeed?.activationReady === 'boolean'
+                        ? cfg.syncV3.combinedFeed.activationReady
+                        : undefined,
+                    syncV3CombinedFeedCoverage: combinedFeedWire?.coverage,
                 });
             }
             catch {
@@ -379,6 +438,7 @@ export function useTaskforce({ config = {}, initialTaskId, onTaskCountChange, on
     const [isOpen, setIsOpen] = useState(false);
     const [showArchive, setShowArchive] = useState(false);
     const [taskScope, setTaskScope] = useState('open');
+    const [compressedCards, setCompressedCards] = useState(false);
     // Settings state
     const [currentTheme, setCurrentTheme] = useState(normalizeTaskforceTheme(mergedConfig.theme) || DEFAULT_TASKFORCE_THEME);
     const [globalTheme, setGlobalTheme] = useState(normalizeTaskforceTheme(mergedConfig.theme) || DEFAULT_TASKFORCE_THEME);
@@ -442,7 +502,6 @@ export function useTaskforce({ config = {}, initialTaskId, onTaskCountChange, on
     const authSessionLastCheckedAtRef = useRef(0);
     const authSessionLastResultRef = useRef(hasOptimisticLocalAuth);
     const currentWorkspaceIdRef = useRef(currentWorkspaceId);
-    const pendingPersistedTaxonomyUiStateRef = useRef(null);
     const explicitWorkspaceSelectionRef = useRef(null);
     const workspaceTransitionEpochRef = useRef(0);
     const bootstrapTraceSeedRef = useRef((() => {
@@ -464,7 +523,7 @@ export function useTaskforce({ config = {}, initialTaskId, onTaskCountChange, on
         if (!nextWorkspaceId)
             return;
         const previousWorkspaceId = String(currentWorkspaceIdRef.current || '').trim();
-        if (previousWorkspaceId && previousWorkspaceId !== nextWorkspaceId) {
+        if (!options?.skipTransitionReset && previousWorkspaceId && previousWorkspaceId !== nextWorkspaceId) {
             workspaceTransitionEpochRef.current += 1;
             setWorkspaceTransitionEpoch(workspaceTransitionEpochRef.current);
         }
@@ -495,6 +554,7 @@ export function useTaskforce({ config = {}, initialTaskId, onTaskCountChange, on
         workspaceId: String(currentWorkspaceIdRef.current || 'default').trim() || 'default',
         epoch: workspaceTransitionEpochRef.current
     }), []);
+    const getCurrentWorkspaceId = useCallback(() => currentWorkspaceIdRef.current, []);
     const isWorkspaceRequestStale = useCallback((requestState) => {
         const liveWorkspaceId = String(currentWorkspaceIdRef.current || 'default').trim() || 'default';
         return liveWorkspaceId !== requestState.workspaceId || workspaceTransitionEpochRef.current !== requestState.epoch;
@@ -541,7 +601,6 @@ export function useTaskforce({ config = {}, initialTaskId, onTaskCountChange, on
     const [buildInfo, setBuildInfo] = useState(null);
     const [keyShortcut, setKeyShortcut] = useState(mergedConfig.shortcut || 'Alt+T');
     const [priorities, setPriorities] = useState(mergedConfig.priorities || []);
-    const [approaches] = useState(cloneDefaultWorkflowDefinitions());
     const [mcpHostRoot, setMcpHostRoot] = useState('');
     const [jsonBackupEnabled, setJsonBackupEnabled] = useState(false);
     const [globalJsonBackupEnabled, setGlobalJsonBackupEnabled] = useState(false);
@@ -559,7 +618,7 @@ export function useTaskforce({ config = {}, initialTaskId, onTaskCountChange, on
     });
     const [manualComplexityEnabled, setManualComplexityEnabled] = useState(false);
     const [checklistDropdownEnabled, setChecklistDropdownEnabled] = useState(true);
-    const [showTaskCardStatusLabel, setShowTaskCardStatusLabel] = useState(true);
+    const [showTaskCardStatusLabel, setShowTaskCardStatusLabel] = useState(false);
     const [serverHostRoot, setServerHostRoot] = useState('');
     const [returnTab, setReturnTab] = useState(null);
     useTaskforceApiRouting({
@@ -567,22 +626,19 @@ export function useTaskforce({ config = {}, initialTaskId, onTaskCountChange, on
         resolveApiUrl,
         runtimeMode
     });
-    const { availableWorkflows, initiativeTemplates, fetchWorkflows, fetchInitiativeTemplates, fetchWorkflowTemplate, fetchWorkflowOverrideNames, saveWorkflowTemplateDraft, resetWorkflowTemplateDraft } = useWorkflowTemplates({
+    const { initiativeTemplates, fetchInitiativeTemplates } = useInitiativeTemplates({
         shouldDeferProtectedApiCalls,
         shouldBlockProtectedApiCalls
     });
     const { zenMode, setZenModeState, toggleZenMode } = useZenMode();
-    const { exportEnvironment, setExportEnvironment, availableEnvironments, loadAvailableEnvironments, exportWorkflowsPath, setExportWorkflowsPath, exportingResource, exportResult, handleExportWorkflows } = useResourceExport({
-        storagePath,
-        shouldDeferProtectedApiCalls,
-        shouldBlockProtectedApiCalls
-    });
     // Unsaved Changes Modal State
     const [unsavedModalOpen, setUnsavedModalOpen] = useState(false);
     const [pendingNavigation, setPendingNavigation] = useState(null);
     // === SECTION: UI Notice ===
     // Delegated to useUiNotice — see src/hooks/useUiNotice.ts
     const { uiNotice, pushNotice, clearNotice } = useUiNotice();
+    const uiNoticeRef = useRef(uiNotice);
+    uiNoticeRef.current = uiNotice;
     const [taskReturnTrail, setTaskReturnTrail] = useState([]);
     const tasksScrollRef = useRef(null);
     const [tasksScrollPos, setTasksScrollPos] = useState(0);
@@ -601,9 +657,21 @@ export function useTaskforce({ config = {}, initialTaskId, onTaskCountChange, on
     const [initiatives, setInitiatives] = useState([]);
     const [workstreams, setWorkstreams] = useState([]);
     const [planningBootstrapTaskSummaries, setPlanningBootstrapTaskSummaries] = useState([]);
+    const [planningLoadState, setPlanningLoadState] = useState(createInitialPlanningLoadState);
     const [deletedTasks, setDeletedTasks] = useState([]);
+    const [archiveHydratedWorkspaceId, setArchiveHydratedWorkspaceId] = useState(null);
+    const [deletedHydratedWorkspaceId, setDeletedHydratedWorkspaceId] = useState(null);
+    const [archiveLookupSettledKeys, setArchiveLookupSettledKeys] = useState(() => new Set());
+    const archiveHydrationRequestRef = useRef(null);
+    const deletedHydrationRequestRef = useRef(null);
     const [loadingTasks, setLoadingTasks] = useState(false);
     const [editingTaskId, setEditingTaskId] = useState(null);
+    const [pendingOpenTaskId, setPendingOpenTaskId] = useState(null);
+    const setPendingOpenTaskIdFromPersistedState = useCallback((taskId) => {
+        if (String(initialTaskId || '').trim())
+            return;
+        setPendingOpenTaskId(taskId);
+    }, [initialTaskId]);
     const [showMarkdownHelp, setShowMarkdownHelp] = useState(false);
     // copiedId is managed by useTaskMutations below.
     // Custom categories
@@ -769,6 +837,7 @@ export function useTaskforce({ config = {}, initialTaskId, onTaskCountChange, on
     // Form state
     const [loading, setLoading] = useState(false);
     const [error, setError] = useState('');
+    const clearTaskError = useCallback(() => setError(''), []);
     const AUTH_REQUIRED_ERROR = 'Authentication required. Sign in to continue.';
     const [referenceDataLoaded, setReferenceDataLoaded] = useState(false);
     const [assigneeOptionsLoaded, setAssigneeOptionsLoaded] = useState(false);
@@ -789,7 +858,7 @@ export function useTaskforce({ config = {}, initialTaskId, onTaskCountChange, on
         setTasks,
         setArchivedTasks,
         setLoadingTasks,
-        getCurrentWorkspaceId: () => currentWorkspaceIdRef.current,
+        getCurrentWorkspaceId,
         workspaceResetKey: `${currentWorkspaceId}:${workspaceTransitionEpoch}`,
         shouldDeferProtectedApiCalls,
         shouldBlockProtectedApiCalls,
@@ -800,36 +869,37 @@ export function useTaskforce({ config = {}, initialTaskId, onTaskCountChange, on
         if (workspaceTransitionEpoch === 0)
             return;
         referenceDataRequestRef.current = null;
-        lastLoadedUiStateKeyRef.current = '';
         lastAssigneeOptionsLoadKeyRef.current = '';
         lastConfigRefreshKeyRef.current = '';
         lastWorkspaceSyncStateLoadKeyRef.current = '';
         lastTaskSurfaceLoadKeyRef.current = '';
         lastSettingsSurfaceLoadKeyRef.current = '';
-        setUiStateReady(false);
         setReferenceDataLoaded(false);
         setAssigneeOptions(createDefaultAssigneeOptions());
         setAssigneeOptionsLoaded(false);
         setDeletedTasks([]);
+        setArchiveHydratedWorkspaceId(null);
+        setDeletedHydratedWorkspaceId(null);
+        setArchiveLookupSettledKeys(new Set());
+        archiveHydrationRequestRef.current = null;
+        deletedHydrationRequestRef.current = null;
         setTasks([]);
         setArchivedTasks([]);
+        setInitiatives([]);
+        setWorkstreams([]);
+        setPlanningBootstrapTaskSummaries([]);
+        setPlanningLoadState(createInitialPlanningLoadState());
+        setPendingOpenTaskId(null);
         setLoadingTasks(false);
-        if (cloudRealtimeFollowUpRefreshTimerRef.current !== null && typeof window !== 'undefined') {
-            window.clearTimeout(cloudRealtimeFollowUpRefreshTimerRef.current);
-            cloudRealtimeFollowUpRefreshTimerRef.current = null;
-        }
-        if (archiveBootstrapTimerRef.current !== null && typeof window !== 'undefined') {
-            window.clearTimeout(archiveBootstrapTimerRef.current);
-            archiveBootstrapTimerRef.current = null;
-        }
     }, [setArchivedTasks, setLoadingTasks, setTasks, workspaceTransitionEpoch]);
     const fetchDeletedTasks = useCallback(async (isSilent = false, options) => {
         const ignoreAuthGuard = options?.ignoreAuthGuard === true;
         if (!ignoreAuthGuard && (shouldDeferProtectedApiCalls || shouldBlockProtectedApiCalls))
-            return;
+            return false;
         if (!isSilent)
             setLoadingTasks(true);
         const requestState = getWorkspaceRequestState();
+        deletedTasksAbortRef.current?.abort('superseded');
         const abortController = new AbortController();
         deletedTasksAbortRef.current = abortController;
         try {
@@ -840,16 +910,20 @@ export function useTaskforce({ config = {}, initialTaskId, onTaskCountChange, on
             if (res.status === 401) {
                 handleUnauthorized();
                 setDeletedTasks([]);
-                return;
+                return false;
             }
             if (res.status === 404) {
-                setDeletedTasks([]);
-                return;
+                if (!isWorkspaceRequestStale(requestState)) {
+                    setDeletedTasks([]);
+                    setDeletedHydratedWorkspaceId(requestState.workspaceId);
+                    return true;
+                }
+                return false;
             }
             if (res.ok) {
                 const data = await res.json();
                 if (isWorkspaceRequestStale(requestState)) {
-                    return;
+                    return false;
                 }
                 const sanitized = Array.isArray(data?.deleted)
                     ? data.deleted
@@ -867,12 +941,16 @@ export function useTaskforce({ config = {}, initialTaskId, onTaskCountChange, on
                         .filter((entry) => Boolean(entry))
                     : [];
                 setDeletedTasks(sanitized);
+                setDeletedHydratedWorkspaceId(requestState.workspaceId);
+                return true;
             }
+            return false;
         }
         catch (err) {
             if (isExpectedWorkspaceAbortFailure(err, abortController.signal) || isAbortError(err))
-                return;
+                return false;
             console.error('[Taskforce] Failed to fetch deleted tasks:', err);
+            return false;
         }
         finally {
             if (deletedTasksAbortRef.current === abortController) {
@@ -901,6 +979,10 @@ export function useTaskforce({ config = {}, initialTaskId, onTaskCountChange, on
         }
         const abortController = new AbortController();
         planningEntitiesAbortRef.current = abortController;
+        setPlanningLoadState((current) => ({
+            ...current,
+            isRefreshing: true,
+        }));
         try {
             const planningTraceId = buildBootstrapTraceId({
                 workspaceId: requestState.workspaceId,
@@ -937,19 +1019,35 @@ export function useTaskforce({ config = {}, initialTaskId, onTaskCountChange, on
                 }
             };
             let bootstrapPayload = null;
+            let collectionStatus = {
+                initiatives: 'ready',
+                workstreams: 'ready',
+            };
             const bootstrapRes = await fetchPlanningRoute('/api/taskforce/planning/bootstrap');
             if (bootstrapRes?.status === 401) {
                 handleUnauthorized();
                 setInitiatives([]);
                 setWorkstreams([]);
                 setPlanningBootstrapTaskSummaries([]);
+                setPlanningLoadState({
+                    status: 'error',
+                    error: 'Sign in again to load Planning.',
+                    isRefreshing: false,
+                    collections: { initiatives: 'error', workstreams: 'error' },
+                });
                 return;
             }
             if (bootstrapRes === null) {
                 throw createBootstrapTimeoutError(PLANNING_BOOTSTRAP_REQUEST_TIMEOUT_MS);
             }
             if (bootstrapRes.ok) {
-                bootstrapPayload = sanitizePlanningBootstrapPayload(await bootstrapRes.json().catch(() => ({})));
+                const bootstrapData = await bootstrapRes.json().catch(() => null);
+                if (!bootstrapData
+                    || !Array.isArray(bootstrapData.initiatives)
+                    || !Array.isArray(bootstrapData.workstreams)) {
+                    throw new Error('Planning returned an incomplete response.');
+                }
+                bootstrapPayload = sanitizePlanningBootstrapPayload(bootstrapData);
             }
             else {
                 const [initiativesRes, workstreamsRes] = await Promise.all([
@@ -964,15 +1062,41 @@ export function useTaskforce({ config = {}, initialTaskId, onTaskCountChange, on
                     setInitiatives([]);
                     setWorkstreams([]);
                     setPlanningBootstrapTaskSummaries([]);
+                    setPlanningLoadState({
+                        status: 'error',
+                        error: 'Sign in again to load Planning.',
+                        isRefreshing: false,
+                        collections: { initiatives: 'error', workstreams: 'error' },
+                    });
                     return;
                 }
-                const [initiativesData, workstreamsData] = await Promise.all([
-                    initiativesRes.ok ? initiativesRes.json().catch(() => []) : [],
-                    workstreamsRes.ok ? workstreamsRes.json().catch(() => []) : [],
+                const readCollection = async (response, key) => {
+                    if (!response.ok)
+                        return { items: [], status: 'error' };
+                    const data = await response.json().catch(() => null);
+                    const items = Array.isArray(data)
+                        ? data
+                        : data && typeof data === 'object' && Array.isArray(data[key])
+                            ? data[key]
+                            : null;
+                    return items
+                        ? { items, status: 'ready' }
+                        : { items: [], status: 'error' };
+                };
+                const [initiativeResult, workstreamResult] = await Promise.all([
+                    readCollection(initiativesRes, 'initiatives'),
+                    readCollection(workstreamsRes, 'workstreams'),
                 ]);
+                collectionStatus = {
+                    initiatives: initiativeResult.status,
+                    workstreams: workstreamResult.status,
+                };
+                if (collectionStatus.initiatives === 'error' && collectionStatus.workstreams === 'error') {
+                    throw new Error('Planning could not be loaded.');
+                }
                 bootstrapPayload = sanitizePlanningBootstrapPayload({
-                    initiatives: initiativesData,
-                    workstreams: workstreamsData,
+                    initiatives: initiativeResult.items,
+                    workstreams: workstreamResult.items,
                     workstreamTaskSummaries: [],
                 });
             }
@@ -982,6 +1106,14 @@ export function useTaskforce({ config = {}, initialTaskId, onTaskCountChange, on
             setInitiatives(bootstrapPayload.initiatives);
             setWorkstreams(bootstrapPayload.workstreams);
             setPlanningBootstrapTaskSummaries(bootstrapPayload.workstreamTaskSummaries);
+            const isPartial = collectionStatus.initiatives === 'error' || collectionStatus.workstreams === 'error';
+            const isEmpty = bootstrapPayload.initiatives.length === 0 && bootstrapPayload.workstreams.length === 0;
+            setPlanningLoadState({
+                status: isPartial ? 'partial' : isEmpty ? 'empty' : 'ready',
+                error: isPartial ? 'Some planning data could not be loaded.' : null,
+                isRefreshing: false,
+                collections: collectionStatus,
+            });
         }
         catch (err) {
             if (isExpectedWorkspaceAbortFailure(err, abortController.signal) || isAbortError(err))
@@ -998,6 +1130,19 @@ export function useTaskforce({ config = {}, initialTaskId, onTaskCountChange, on
             else {
                 console.error('[Taskforce] Failed to fetch planning entities:', err);
             }
+            if (!isWorkspaceRequestStale(requestState)) {
+                const hasExistingPlanningData = initiatives.length > 0 || workstreams.length > 0;
+                setPlanningLoadState((current) => ({
+                    status: hasExistingPlanningData ? 'partial' : 'error',
+                    error: err instanceof Error && err.message
+                        ? err.message
+                        : 'Planning could not be loaded.',
+                    isRefreshing: false,
+                    collections: hasExistingPlanningData
+                        ? current.collections
+                        : { initiatives: 'error', workstreams: 'error' },
+                }));
+            }
             if (typeof window !== 'undefined'
                 && !isWorkspaceRequestStale(requestState)
                 && initiatives.length === 0
@@ -1025,31 +1170,167 @@ export function useTaskforce({ config = {}, initialTaskId, onTaskCountChange, on
         shouldBlockProtectedApiCalls,
         workstreams.length,
     ]);
+    const fetchPlanningEntityDetail = useCallback(async (entityType, id) => {
+        const normalizedId = String(id || '').trim();
+        if (!normalizedId) {
+            throw new Error(`Cannot load ${entityType} details without an id.`);
+        }
+        const requestState = getWorkspaceRequestState();
+        const res = await fetch(`/api/taskforce/${entityType}/${encodeURIComponent(normalizedId)}`);
+        const data = await res.json().catch(() => ({}));
+        if (!res.ok) {
+            throw new Error(data?.error || `Failed to load ${entityType} details (${res.status})`);
+        }
+        const entity = data;
+        if (!isWorkspaceRequestStale(requestState)) {
+            if (entityType === 'initiative') {
+                setInitiatives((current) => upsertEntityById(current, entity));
+            }
+            else {
+                setWorkstreams((current) => upsertEntityById(current, entity));
+            }
+        }
+        return entity;
+    }, [getWorkspaceRequestState, isWorkspaceRequestStale]);
     const fetchTasks = useCallback(async (isSilent = false, options) => {
         await fetchTasksBase(isSilent, options);
     }, [fetchTasksBase]);
     const fetchArchive = useCallback(async (isSilent = false, options) => {
-        await fetchArchiveBase(isSilent, options);
+        const requestWorkspaceId = String(currentWorkspaceIdRef.current || 'default').trim() || 'default';
+        const loaded = await fetchArchiveBase(isSilent, options);
+        const liveWorkspaceId = String(currentWorkspaceIdRef.current || 'default').trim() || 'default';
+        if (loaded && liveWorkspaceId === requestWorkspaceId) {
+            setArchiveHydratedWorkspaceId(requestWorkspaceId);
+        }
+        return loaded;
     }, [fetchArchiveBase]);
+    const ensureArchiveHydrated = useCallback((isSilent = true, options) => {
+        const workspaceId = String(currentWorkspaceIdRef.current || 'default').trim() || 'default';
+        if (archiveHydratedWorkspaceId === workspaceId)
+            return Promise.resolve(true);
+        const pending = archiveHydrationRequestRef.current;
+        if (pending?.workspaceId === workspaceId)
+            return pending.promise;
+        const promise = fetchArchive(isSilent, options).finally(() => {
+            if (archiveHydrationRequestRef.current?.promise === promise) {
+                archiveHydrationRequestRef.current = null;
+            }
+        });
+        archiveHydrationRequestRef.current = { workspaceId, promise };
+        return promise;
+    }, [archiveHydratedWorkspaceId, fetchArchive]);
+    const ensureDeletedTasksHydrated = useCallback((isSilent = true, options) => {
+        const workspaceId = String(currentWorkspaceIdRef.current || 'default').trim() || 'default';
+        if (deletedHydratedWorkspaceId === workspaceId)
+            return Promise.resolve(true);
+        const pending = deletedHydrationRequestRef.current;
+        if (pending?.workspaceId === workspaceId)
+            return pending.promise;
+        const promise = fetchDeletedTasks(isSilent, options).finally(() => {
+            if (deletedHydrationRequestRef.current?.promise === promise) {
+                deletedHydrationRequestRef.current = null;
+            }
+        });
+        deletedHydrationRequestRef.current = { workspaceId, promise };
+        return promise;
+    }, [deletedHydratedWorkspaceId, fetchDeletedTasks]);
+    const refreshArchiveIfHydrated = useCallback(() => {
+        const workspaceId = String(currentWorkspaceIdRef.current || 'default').trim() || 'default';
+        if (archiveHydratedWorkspaceId !== workspaceId)
+            return Promise.resolve(false);
+        return fetchArchive(true);
+    }, [archiveHydratedWorkspaceId, fetchArchive]);
+    const refreshDeletedTasksIfHydrated = useCallback((isSilent = true) => {
+        const workspaceId = String(currentWorkspaceIdRef.current || 'default').trim() || 'default';
+        if (deletedHydratedWorkspaceId !== workspaceId)
+            return Promise.resolve(false);
+        return fetchDeletedTasks(isSilent);
+    }, [deletedHydratedWorkspaceId, fetchDeletedTasks]);
     const refreshTaskCollections = useCallback(async (options) => {
         const isSilent = options?.isSilent !== false;
         const ignoreAuthGuard = options?.ignoreAuthGuard === true;
+        const workspaceId = String(currentWorkspaceIdRef.current || 'default').trim() || 'default';
+        const includeArchive = archiveHydratedWorkspaceId === workspaceId;
+        const includeDeleted = deletedHydratedWorkspaceId === workspaceId;
         await Promise.all([
-            refreshTaskCollectionsBase({ isSilent, ignoreAuthGuard }),
-            fetchDeletedTasks(isSilent, { ignoreAuthGuard }),
+            refreshTaskCollectionsBase({
+                isSilent,
+                ignoreAuthGuard,
+                includeArchive,
+                highlightChangedTaskIds: options?.highlightChangedTaskIds,
+            }),
+            includeDeleted
+                ? fetchDeletedTasks(isSilent, { ignoreAuthGuard })
+                : Promise.resolve(false),
             fetchPlanningEntities({ ignoreAuthGuard }),
         ]);
-    }, [fetchDeletedTasks, fetchPlanningEntities, refreshTaskCollectionsBase]);
-    const refreshTaskCollectionsFromInvalidation = useCallback(async () => {
-        await refreshTaskCollectionsFromInvalidationBase();
-        await fetchDeletedTasks(true);
-        await fetchPlanningEntities();
-    }, [fetchDeletedTasks, fetchPlanningEntities, refreshTaskCollectionsFromInvalidationBase]);
+    }, [
+        archiveHydratedWorkspaceId,
+        deletedHydratedWorkspaceId,
+        fetchDeletedTasks,
+        fetchPlanningEntities,
+        refreshTaskCollectionsBase
+    ]);
+    const taskInvalidationInFlightRef = useRef(false);
+    const pendingTaskInvalidationRef = useRef(null);
+    const archiveHydratedWorkspaceIdRef = useRef(archiveHydratedWorkspaceId);
+    const deletedHydratedWorkspaceIdRef = useRef(deletedHydratedWorkspaceId);
+    const invalidationTaskRefreshRef = useRef(refreshTaskCollectionsFromInvalidationBase);
+    const invalidationDeletedRefreshRef = useRef(fetchDeletedTasks);
+    const invalidationPlanningRefreshRef = useRef(fetchPlanningEntities);
+    archiveHydratedWorkspaceIdRef.current = archiveHydratedWorkspaceId;
+    deletedHydratedWorkspaceIdRef.current = deletedHydratedWorkspaceId;
+    invalidationTaskRefreshRef.current = refreshTaskCollectionsFromInvalidationBase;
+    invalidationDeletedRefreshRef.current = fetchDeletedTasks;
+    invalidationPlanningRefreshRef.current = fetchPlanningEntities;
+    const refreshTaskCollectionsFromInvalidation = useCallback(async (scope) => {
+        const workspaceId = String(currentWorkspaceIdRef.current || 'default').trim() || 'default';
+        const pending = pendingTaskInvalidationRef.current;
+        pendingTaskInvalidationRef.current = {
+            workspaceId,
+            scope: pending?.workspaceId === workspaceId
+                ? mergeTaskInvalidationScopes(pending.scope, scope)
+                : scope,
+        };
+        if (taskInvalidationInFlightRef.current)
+            return;
+        taskInvalidationInFlightRef.current = true;
+        try {
+            while (pendingTaskInvalidationRef.current) {
+                const next = pendingTaskInvalidationRef.current;
+                pendingTaskInvalidationRef.current = null;
+                const requestWorkspaceId = String(currentWorkspaceIdRef.current || 'default').trim() || 'default';
+                if (next.workspaceId !== requestWorkspaceId)
+                    continue;
+                const collections = new Set(next.scope.collections);
+                const includeActive = collections.has('active');
+                const includeArchive = collections.has('archive')
+                    && archiveHydratedWorkspaceIdRef.current === requestWorkspaceId;
+                const includeDeleted = collections.has('deleted')
+                    && deletedHydratedWorkspaceIdRef.current === requestWorkspaceId;
+                const highlightChangedTaskIds = resolveTaskInvalidationHighlightIds(next.scope);
+                await Promise.all([
+                    includeActive || includeArchive
+                        ? invalidationTaskRefreshRef.current({
+                            includeActive,
+                            includeArchive,
+                            highlightChangedTaskIds,
+                        })
+                        : Promise.resolve(),
+                    includeDeleted ? invalidationDeletedRefreshRef.current(true) : Promise.resolve(false),
+                    collections.has('planning') ? invalidationPlanningRefreshRef.current() : Promise.resolve(),
+                ]);
+            }
+        }
+        finally {
+            taskInvalidationInFlightRef.current = false;
+        }
+    }, []);
     const setUserGlobalSyncStatusRef = useRef(() => undefined);
     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, 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, workspacePushInFlightRef, workspacePullInFlightRef, workspaceLastPushedSignatureRef, workspacePendingSignatureRef, workspaceLastPushedTaskIdsRef, workspaceDeletedTaskIdsRef, workspaceDeletedTaskWatermarksRef, workspacePullCursorRef, clearWorkspaceRetry, persistWorkspaceSyncPatch, loadWorkspaceSyncState, applyWorkspaceSyncStateSnapshot, syncUserGlobalSettings, buildWorkspaceSyncSignature, pushWorkspaceChangesToCloud, saveWorkspaceCloudSyncSettings, retryUserGlobalSettingsSync, retryWorkspaceCloudSync, resetWorkspaceSyncCursorAndPull, getWorkspaceSyncDiagnostics } = useSyncOrchestrator({
         currentWorkspaceId,
         cloudAuthConfigured,
         runtimeMode,
@@ -1060,6 +1341,11 @@ export function useTaskforce({ config = {}, initialTaskId, onTaskCountChange, on
         resolveCloudAuthUrl,
         resolveWebSocketUrl,
         realtimeSyncEnabled,
+        localOutboxDispatchEnabled: runtimeConfigOverride.syncV3LocalOutboxDispatch,
+        localCoordinatorBrowserAuthorityGateEnabled: runtimeConfigOverride.localCoordinatorBrowserAuthorityGate,
+        initiativeFeedActivationEnabled: runtimeConfigOverride.syncV3InitiativeFeedActivation,
+        combinedFeedActivationEnabled: runtimeConfigOverride.syncV3CombinedFeedActivation,
+        combinedFeedCoverage: runtimeConfigOverride.syncV3CombinedFeedCoverage,
         tasks,
         archivedTasks,
         deletedTasks,
@@ -1094,20 +1380,50 @@ export function useTaskforce({ config = {}, initialTaskId, onTaskCountChange, on
     const [priority, setPriority] = useState(2);
     const [complexity, setComplexity] = useState(3);
     const [status, setStatus] = useState('task');
-    const [approach, setApproach] = useState('default');
     const [assignee, setAssignee] = useState('unassigned');
     const [scheduledDate, setScheduledDate] = useState('');
     const [dueDate, setDueDate] = useState('');
     const [workstreamInput, setWorkstreamInput] = useState('');
     const [title, setTitle] = useState('');
     const [description, setDescription] = useState('');
+    const titleDraftRef = useRef(title);
+    const descriptionDraftRef = useRef(description);
+    const textDraftOccupiedRef = useRef(false);
+    const [textDraftOccupied, setTextDraftOccupied] = useState(false);
+    const refreshTextDraftOccupied = useCallback(() => {
+        const occupied = titleDraftRef.current.trim() !== '' || descriptionDraftRef.current.trim() !== '';
+        if (occupied === textDraftOccupiedRef.current)
+            return;
+        textDraftOccupiedRef.current = occupied;
+        setTextDraftOccupied(occupied);
+    }, []);
+    const setTitleDraft = useCallback((value) => {
+        titleDraftRef.current = value;
+        refreshTextDraftOccupied();
+    }, [refreshTextDraftOccupied]);
+    const setDescriptionDraft = useCallback((value) => {
+        descriptionDraftRef.current = value;
+        refreshTextDraftOccupied();
+    }, [refreshTextDraftOccupied]);
+    const getTitleDraft = useCallback(() => titleDraftRef.current, []);
+    const getDescriptionDraft = useCallback(() => descriptionDraftRef.current, []);
+    useEffect(() => {
+        titleDraftRef.current = title;
+        refreshTextDraftOccupied();
+    }, [refreshTextDraftOccupied, title]);
+    useEffect(() => {
+        descriptionDraftRef.current = description;
+        refreshTextDraftOccupied();
+    }, [description, refreshTextDraftOccupied]);
     const [checklistItems, setChecklistItems] = useState([]);
     const [comments, setComments] = useState([]);
     const [newCommentText, setNewCommentText] = useState('');
     const [formTaxonomies, setFormTaxonomies] = useState({});
     const commentsEndRef = useRef(null);
-    const [showChecklist, setShowChecklist] = useState(false);
     const [lastUsedCategory, setLastUsedCategory] = useState('');
+    const [taskforceAgentId, setTaskforceAgentId] = useState('');
+    const [taskforceAgentConversationId, setTaskforceAgentConversationId] = useState('');
+    const [taskforceAgentConversationByAgentId, setTaskforceAgentConversationByAgentId] = useState({});
     useEffect(() => {
         if (editingTaskId)
             return;
@@ -1176,37 +1492,63 @@ export function useTaskforce({ config = {}, initialTaskId, onTaskCountChange, on
     });
     checkAuthSessionImplRef.current = checkAuthSessionImpl;
     const [activeWorkspaceModule, setActiveWorkspaceModuleState] = useState('tasks');
-    const [showComments, setShowComments] = useState(false);
     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 cloudRealtimeFollowUpRefreshTimerRef = useRef(null);
-    const archiveBootstrapTimerRef = useRef(null);
+    const ambiguousRealtimeConfirmationTimerRef = useRef(null);
     const skippedInitialTaskTabRefreshRef = useRef(false);
     const authSessionResolvedRef = useRef(authSessionResolved);
     const authRequiredForApiRef = useRef(authRequiredForApi);
     const isAuthenticatedRef = useRef(isAuthenticated);
-    const hasLoadedUiStateRef = useRef(false);
-    const lastLoadedUiStateKeyRef = useRef('');
     const lastAssigneeOptionsLoadKeyRef = useRef('');
     const lastConfigRefreshKeyRef = useRef('');
     const lastWorkspaceSyncStateLoadKeyRef = useRef('');
     const lastTaskSurfaceLoadKeyRef = useRef('');
     const lastSettingsSurfaceLoadKeyRef = useRef('');
-    const skipNextUiStatePersistRef = useRef(false);
-    const activeWorkspaceModuleOverridePendingRef = useRef(false);
     const referenceDataRequestRef = useRef(null);
     const workspaceListHydratedRef = useRef(false);
     const hasBootstrappedDataRef = useRef(false);
-    const [uiStateReady, setUiStateReady] = useState(false);
-    const setActiveWorkspaceModule = useCallback((nextModule) => {
-        if (!uiStateReady) {
-            activeWorkspaceModuleOverridePendingRef.current = true;
-        }
-        setActiveWorkspaceModuleState(nextModule);
-    }, [uiStateReady]);
     const { handleSaveSettings, handleSaveTheme, handleSaveGlobalTheme, handleJsonBackupEnabledChange, handleSaveGlobalJsonBackupEnabled, handleSaveGlobalWeekStartsOn, handleSaveLocale, handleManualComplexityEnabledChange, handleChecklistDropdownEnabledChange, handleShowTaskCardStatusLabelChange, handleResetProjectToGlobal } = useSettingsPersistence({
         keyShortcut,
         themeUseGlobalDefault,
@@ -1224,8 +1566,7 @@ export function useTaskforce({ config = {}, initialTaskId, onTaskCountChange, on
         setLocale,
         setManualComplexityEnabled,
         setChecklistDropdownEnabled,
-        setShowTaskCardStatusLabel,
-        setShowChecklist
+        setShowTaskCardStatusLabel
     });
     useEffect(() => {
         if (runtimeMode !== 'cloud')
@@ -1239,233 +1580,63 @@ export function useTaskforce({ config = {}, initialTaskId, onTaskCountChange, on
         authRequiredForApiRef.current = authRequiredForApi;
         isAuthenticatedRef.current = isAuthenticated;
     }, [authSessionResolved, authRequiredForApi, isAuthenticated]);
-    const currentFilterTaxonomySignature = useMemo(() => (referenceDataLoaded
-        ? buildFilterTaxonomySignature({
-            categories: activeCategories,
-            types: activeTypes,
-            priorities,
-            taxonomies
-        })
-        : null), [activeCategories, activeTypes, priorities, referenceDataLoaded, taxonomies]);
-    const applyPersistedUiState = useCallback((state, options) => {
-        if (!state) {
-            pendingPersistedTaxonomyUiStateRef.current = null;
-            return;
-        }
-        const hasPersistedTaxonomyFilterState = Array.isArray(state.filterCategories)
-            || Array.isArray(state.filterPriorities)
-            || Array.isArray(state.filterTypes)
-            || (state.filterTaxonomies && typeof state.filterTaxonomies === 'object');
-        if (!hasPersistedTaxonomyFilterState) {
-            pendingPersistedTaxonomyUiStateRef.current = null;
-        }
-        const hasPersistedFilterState = Array.isArray(state.filterCategories)
-            || Array.isArray(state.filterPriorities)
-            || Array.isArray(state.filterTypes)
-            || Array.isArray(state.filterStatus)
-            || Array.isArray(state.filterAssignees)
-            || typeof state.filterAssigneesAllSelected === 'boolean'
-            || (state.filterTaxonomies && typeof state.filterTaxonomies === 'object');
-        const canCompareTaxonomySignature = currentFilterTaxonomySignature !== null;
-        if (hasPersistedTaxonomyFilterState && !canCompareTaxonomySignature) {
-            pendingPersistedTaxonomyUiStateRef.current = {
-                state,
-                skipActiveWorkspaceModule: options?.skipActiveWorkspaceModule
-            };
-        }
-        const canApplyTaxonomyFilters = hasPersistedTaxonomyFilterState
-            && canCompareTaxonomySignature
-            && areFilterTaxonomySignaturesEqual(state.filterTaxonomySignature, currentFilterTaxonomySignature);
-        const shouldResetTaxonomyFilters = hasPersistedTaxonomyFilterState
-            && canCompareTaxonomySignature
-            && !canApplyTaxonomyFilters;
-        const taxonomyFiltersAreReady = !hasPersistedTaxonomyFilterState || canApplyTaxonomyFilters || shouldResetTaxonomyFilters;
-        if (!options?.skipActiveWorkspaceModule) {
-            if (typeof state.activeWorkspaceModule === 'string') {
-                setActiveWorkspaceModuleState(state.activeWorkspaceModule);
-            }
-            else if (state.groupBy === 'docs') {
-                setActiveWorkspaceModuleState('docs');
-            }
-        }
-        if (state.groupBy && state.groupBy !== 'docs')
-            setGroupBy(state.groupBy);
-        if (state.emptyColumnMode === 'show' || state.emptyColumnMode === 'collapse' || state.emptyColumnMode === 'hide')
-            setEmptyColumnMode(state.emptyColumnMode);
-        if (typeof state.zenMode === 'boolean')
-            setZenModeState(state.zenMode);
-        if (typeof state.searchQuery === 'string')
-            setSearchQuery(state.searchQuery);
-        if (canApplyTaxonomyFilters) {
-            if (Array.isArray(state.filterCategories))
-                setFilterCategories(state.filterCategories);
-            if (Array.isArray(state.filterPriorities))
-                setFilterPriorities(state.filterPriorities);
-            if (Array.isArray(state.filterTypes))
-                setFilterTypes(state.filterTypes);
-            if (state.filterTaxonomies && typeof state.filterTaxonomies === 'object')
-                setFilterTaxonomies(state.filterTaxonomies);
-        }
-        else if (shouldResetTaxonomyFilters) {
-            setFilterCategories(activeCategories.map((category) => category.value));
-            setFilterPriorities(priorities.map((priority) => priority.value));
-            setFilterTypes(activeTypes.map((type) => type.value));
-            setFilterTaxonomies({});
-        }
-        if (Array.isArray(state.filterStatus))
-            setFilterStatus(state.filterStatus);
-        if (Array.isArray(state.filterAssignees))
-            setFilterAssignees(state.filterAssignees);
-        if (typeof state.filterAssigneesAllSelected === 'boolean')
-            setFilterAssigneesAllSelected(state.filterAssigneesAllSelected);
-        if (state.sortBy === 'created' || state.sortBy === 'priority' || state.sortBy === 'updated' || state.sortBy === 'complexity')
-            setSortBy(state.sortBy);
-        if (state.sortOrder === 'asc' || state.sortOrder === 'desc')
-            setSortOrder(state.sortOrder);
-        if (shouldResetTaxonomyFilters) {
-            setHasInitedFilters(true);
-        }
-        else if (typeof state.hasInitedFilters === 'boolean' && taxonomyFiltersAreReady) {
-            setHasInitedFilters(state.hasInitedFilters);
-        }
-        else if (hasPersistedFilterState && taxonomyFiltersAreReady) {
-            setHasInitedFilters(true);
-        }
-        if (typeof state.showChecklist === 'boolean')
-            setShowChecklist(state.showChecklist);
-        if (typeof state.lastCategory === 'string')
-            setLastUsedCategory(state.lastCategory);
-        if (typeof state.exportEnvironment === 'string' && state.exportEnvironment.trim().length > 0) {
-            setExportEnvironment(state.exportEnvironment.trim());
-        }
-    }, [activeCategories, activeTypes, currentFilterTaxonomySignature, priorities]);
-    useEffect(() => {
-        if (!currentFilterTaxonomySignature || !pendingPersistedTaxonomyUiStateRef.current)
-            return;
-        const pending = pendingPersistedTaxonomyUiStateRef.current;
-        pendingPersistedTaxonomyUiStateRef.current = null;
-        applyPersistedUiState(pending.state, {
-            skipActiveWorkspaceModule: pending.skipActiveWorkspaceModule
-        });
-    }, [applyPersistedUiState, currentFilterTaxonomySignature]);
-    const loadPersistedUiState = useCallback(async (workspaceIdOverride) => {
-        const targetWorkspaceId = String(workspaceIdOverride || currentWorkspaceIdRef.current || currentWorkspaceId || 'default').trim() || 'default';
-        const uiStateLoadKey = `${runtimeMode}:${workspaceUiStateScope}:${targetWorkspaceId}`;
-        try {
-            const res = await fetch(`/api/taskforce/ui-state?key=app&workspaceId=${encodeURIComponent(targetWorkspaceId)}`, {
-                method: 'GET',
-                credentials: 'include'
-            });
-            const data = res.ok ? await res.json().catch(() => ({})) : {};
-            const serverState = (data?.state && typeof data.state === 'object')
-                ? data.state
-                : null;
-            const localState = readPersistedAppUiState(workspaceUiStateScope);
-            const state = serverState || localState
-                ? {
-                    ...(localState || {}),
-                    ...(serverState || {})
-                }
-                : null;
-            if (currentWorkspaceIdRef.current !== targetWorkspaceId) {
-                return;
-            }
-            applyPersistedUiState(state, {
-                skipActiveWorkspaceModule: activeWorkspaceModuleOverridePendingRef.current
-            });
-            lastLoadedUiStateKeyRef.current = uiStateLoadKey;
-        }
-        catch {
-            const localState = readPersistedAppUiState(workspaceUiStateScope);
-            if (currentWorkspaceIdRef.current === targetWorkspaceId) {
-                applyPersistedUiState(localState, {
-                    skipActiveWorkspaceModule: activeWorkspaceModuleOverridePendingRef.current
-                });
-                lastLoadedUiStateKeyRef.current = uiStateLoadKey;
-            }
-        }
-        finally {
-            if (currentWorkspaceIdRef.current !== targetWorkspaceId)
-                return;
-            activeWorkspaceModuleOverridePendingRef.current = false;
-            skipNextUiStatePersistRef.current = true;
-            setUiStateReady(true);
-        }
-    }, [applyPersistedUiState, currentWorkspaceId, runtimeMode, workspaceUiStateScope]);
-    useEffect(() => {
-        const uiStateLoadKey = `${runtimeMode}:${workspaceUiStateScope}:${currentWorkspaceId}`;
-        if (!hasLoadedUiStateRef.current)
-            return;
-        if (lastLoadedUiStateKeyRef.current === uiStateLoadKey)
-            return;
-        setUiStateReady(false);
-        void loadPersistedUiState(currentWorkspaceId);
-    }, [currentWorkspaceId, loadPersistedUiState, runtimeMode, workspaceUiStateScope]);
-    useEffect(() => {
-        if (!uiStateReady)
-            return;
-        if (skipNextUiStatePersistRef.current) {
-            skipNextUiStatePersistRef.current = false;
-            return;
-        }
-        const uiStateSnapshot = {
-            groupBy,
-            activeWorkspaceModule,
-            emptyColumnMode,
-            zenMode,
-            searchQuery,
-            filterCategories,
-            filterPriorities,
-            filterTypes,
-            filterStatus,
-            filterAssignees,
-            filterAssigneesAllSelected,
-            filterTaxonomies,
-            ...(currentFilterTaxonomySignature ? { filterTaxonomySignature: currentFilterTaxonomySignature } : {}),
-            sortBy,
-            sortOrder,
-            hasInitedFilters,
-            showChecklist,
-            lastCategory: lastUsedCategory || '',
-            exportEnvironment
-        };
-        writePersistedAppUiState(uiStateSnapshot, workspaceUiStateScope);
-        const timeoutId = window.setTimeout(async () => {
-            try {
-                await persistRemoteUiState({
-                    stateKey: 'app',
-                    workspaceId: currentWorkspaceIdRef.current,
-                    patch: uiStateSnapshot
-                });
-            }
-            catch {
-                // ignore persistence errors
-            }
-        }, 250);
-        return () => window.clearTimeout(timeoutId);
-    }, [
-        uiStateReady,
-        groupBy,
+    const { hasLoadedUiStateRef, loadPersistedUiState, resetPersistedUiStateLoad, setActiveWorkspaceModule, uiStateReady } = usePersistedAppUiState({
+        runtimeMode,
+        workspaceUiStateScope,
+        currentWorkspaceId,
+        currentWorkspaceIdRef,
+        referenceDataLoaded,
+        activeCategories,
+        activeTypes,
+        priorities,
+        taxonomies,
         activeWorkspaceModule,
+        setActiveWorkspaceModuleState,
+        groupBy,
+        setGroupBy,
         emptyColumnMode,
+        setEmptyColumnMode,
+        taskScope,
+        setTaskScope,
+        openTaskId: editingTaskId,
+        setPendingOpenTaskId: setPendingOpenTaskIdFromPersistedState,
+        compressedCards,
+        setCompressedCards,
         zenMode,
+        setZenModeState,
         searchQuery,
+        setSearchQuery,
+        collapsedCategories,
+        setCollapsedCategories,
         filterCategories,
+        setFilterCategories,
         filterPriorities,
+        setFilterPriorities,
         filterTypes,
+        setFilterTypes,
         filterStatus,
+        setFilterStatus,
         filterAssignees,
+        setFilterAssignees,
         filterAssigneesAllSelected,
+        setFilterAssigneesAllSelected,
         filterTaxonomies,
-        currentFilterTaxonomySignature,
+        setFilterTaxonomies,
         sortBy,
+        setSortBy,
         sortOrder,
+        setSortOrder,
         hasInitedFilters,
-        showChecklist,
+        setHasInitedFilters,
         lastUsedCategory,
-        exportEnvironment,
-        workspaceUiStateScope
-    ]);
+        setLastUsedCategory,
+        taskforceAgentId,
+        setTaskforceAgentId,
+        taskforceAgentConversationId,
+        setTaskforceAgentConversationId,
+        taskforceAgentConversationByAgentId,
+        setTaskforceAgentConversationByAgentId
+    });
     const applyBootstrapConfig = useCallback((data) => {
         const nextRuntimeMode = data.runtimeMode === 'cloud' ? 'cloud' : 'local';
         const nextAuthRequiredForApi = Boolean(data.authRequiredForApi);
@@ -1488,7 +1659,10 @@ export function useTaskforce({ config = {}, initialTaskId, onTaskCountChange, on
         if (typeof data.workspaceId === 'string' && data.workspaceId.trim().length > 0) {
             const nextWorkspaceId = data.workspaceId.trim();
             if (nextRuntimeMode === 'local') {
-                commitCurrentWorkspaceId(nextWorkspaceId);
+                const previousWorkspaceId = String(currentWorkspaceIdRef.current || '').trim() || 'default';
+                commitCurrentWorkspaceId(nextWorkspaceId, {
+                    skipTransitionReset: !configLoaded && previousWorkspaceId === 'default'
+                });
             }
             else {
                 applyResolvedWorkspaceId(nextWorkspaceId);
@@ -1591,9 +1765,9 @@ export function useTaskforce({ config = {}, initialTaskId, onTaskCountChange, on
             setShowTaskCardStatusLabel(data.showTaskCardStatusLabel);
         }
         else {
-            setShowTaskCardStatusLabel(true);
+            setShowTaskCardStatusLabel(false);
         }
-    }, [applyResolvedWorkspaceId, commitCurrentWorkspaceId]);
+    }, [applyResolvedWorkspaceId, commitCurrentWorkspaceId, configLoaded, currentWorkspaceIdRef]);
     const fetchBuildInfo = useCallback(async () => {
         const startedAt = typeof performance !== 'undefined' ? performance.now() : Date.now();
         try {
@@ -1636,9 +1810,7 @@ export function useTaskforce({ config = {}, initialTaskId, onTaskCountChange, on
         fetchBuildInfo,
         markBootstrapPhase,
         markBootstrapStalled,
-        fetchWorkflows,
         fetchInitiativeTemplates,
-        loadAvailableEnvironments,
         setReferenceDataLoaded,
         setCustomCategories,
         setCustomTypes,
@@ -1689,11 +1861,10 @@ export function useTaskforce({ config = {}, initialTaskId, onTaskCountChange, on
         settingsSection,
         workspaceBootstrapPending,
         fetchTasks,
-        fetchArchive,
         fetchPlanningEntities,
         refreshTaskCollections,
         loadWorkspaceSyncState,
-        archiveBootstrapTimerRef,
+        switchLocalCoordinatorWorkspace,
         hasBootstrappedDataRef
     });
     const refreshSetupContext = useCallback(async () => {
@@ -1749,8 +1920,7 @@ export function useTaskforce({ config = {}, initialTaskId, onTaskCountChange, on
         const result = await runCloudBootstrap({
             reason: 'post-plans',
             ignoreAuthGuard: true,
-            tasksSilent: true,
-            includeDeferredArchive: false
+            tasksSilent: true
         });
         if (!result.authenticated) {
             return { success: false, destination: 'login', error: result.error || 'Sign in required.', code: result.code || 'AUTH_REQUIRED' };
@@ -1797,8 +1967,7 @@ export function useTaskforce({ config = {}, initialTaskId, onTaskCountChange, on
         const result = await runCloudBootstrap({
             reason,
             ignoreAuthGuard: true,
-            tasksSilent: true,
-            includeDeferredArchive: false
+            tasksSilent: true
         });
         if (!result.authenticated) {
             return { success: false, error: result.error || 'Sign in required.', code: result.code || 'AUTH_REQUIRED' };
@@ -1979,7 +2148,11 @@ export function useTaskforce({ config = {}, initialTaskId, onTaskCountChange, on
                 method: 'POST',
                 headers: { 'Content-Type': 'application/json' },
                 credentials: 'include',
-                body: JSON.stringify({ email: trimmedEmail, password: rawPassword })
+                body: JSON.stringify(buildTaskforceCredentialLoginPayload({
+                    email: trimmedEmail,
+                    password: rawPassword,
+                    activeWorkspaceId: currentWorkspaceIdRef.current,
+                }))
             });
             const data = await res.json().catch(() => ({}));
             if (!res.ok || !data?.success) {
@@ -1990,24 +2163,34 @@ export function useTaskforce({ config = {}, initialTaskId, onTaskCountChange, on
             if (!entry.success) {
                 return { success: false, error: entry.error || 'Unable to resolve workspace after sign in.', code: entry.code };
             }
+            dispatchTaskforceAuthSessionChanged();
             return { success: true, workspaceSetupRequired: entry.workspaceSetupRequired === true };
         }
         catch {
             return { success: false, error: 'Sign in failed.' };
         }
-    }, [resolveCloudAuthUrl, cloudAuthConfigured, resolvePostAuthCloudEntry]);
+    }, [resolveCloudAuthUrl, cloudAuthConfigured, currentWorkspaceIdRef, resolvePostAuthCloudEntry]);
     /**
      * Initiates an OAuth login (or invite-claim) flow by redirecting the browser
      * to the provider's authorisation URL via the server-side start route.
      *
      * @param provider   - 'google' | 'github' | 'apple'
      * @param returnTo   - Optional relative path to redirect back to after auth (defaults to '/').
-     * @param inviteToken - Optional invite token; when provided the flow uses `invite_claim` mode.
+    * @param inviteToken - Optional invite token; when provided the flow uses `invite_claim` mode.
      */
     const beginOAuthLogin = useCallback((provider, returnTo, inviteToken) => {
-        const sanitizedReturnTo = returnTo && /^\/[A-Za-z0-9_\-./?=&%]*$/.test(returnTo)
-            ? returnTo
-            : '/';
+        let sanitizedReturnTo = '/';
+        try {
+            const parsedReturnTo = new URL(String(returnTo || '/'), 'https://taskforce.local');
+            if (parsedReturnTo.origin === 'https://taskforce.local'
+                && String(returnTo || '/').startsWith('/')
+                && !String(returnTo || '/').startsWith('//')) {
+                sanitizedReturnTo = `${parsedReturnTo.pathname}${parsedReturnTo.search}${parsedReturnTo.hash}`;
+            }
+        }
+        catch {
+            sanitizedReturnTo = '/';
+        }
         let path = `/api/taskforce/auth/oauth/${encodeURIComponent(provider)}/start?return_to=${encodeURIComponent(sanitizedReturnTo)}`;
         if (inviteToken) {
             path += `&invite_token=${encodeURIComponent(inviteToken)}`;
@@ -2407,7 +2590,7 @@ export function useTaskforce({ config = {}, initialTaskId, onTaskCountChange, on
         if (!cloudAuthConfigured)
             return { success: false, error: 'Cloud auth not configured.' };
         try {
-            const res = await fetch(resolveCloudAuthUrl('/api/taskforce/account/login-methods'), {
+            const res = await fetch(resolveCloudAuthUrl('/api/taskforce/auth/login-methods'), {
                 credentials: 'include'
             });
             const data = await res.json().catch(() => ({}));
@@ -2424,7 +2607,7 @@ export function useTaskforce({ config = {}, initialTaskId, onTaskCountChange, on
         if (!cloudAuthConfigured)
             return { success: false, error: 'Cloud auth not configured.' };
         try {
-            const res = await fetch(resolveCloudAuthUrl(`/api/taskforce/account/login-methods/${encodeURIComponent(provider)}`), {
+            const res = await fetch(resolveCloudAuthUrl(`/api/taskforce/auth/login-methods/${encodeURIComponent(provider)}`), {
                 method: 'DELETE',
                 credentials: 'include'
             });
@@ -2442,7 +2625,7 @@ export function useTaskforce({ config = {}, initialTaskId, onTaskCountChange, on
         if (!cloudAuthConfigured)
             return { success: false, error: 'Cloud auth not configured.' };
         try {
-            const res = await fetch(resolveCloudAuthUrl('/api/taskforce/account/login-methods/password'), {
+            const res = await fetch(resolveCloudAuthUrl('/api/taskforce/auth/login-methods/password'), {
                 method: 'POST',
                 headers: { 'Content-Type': 'application/json' },
                 credentials: 'include',
@@ -2458,6 +2641,28 @@ export function useTaskforce({ config = {}, initialTaskId, onTaskCountChange, on
             return { success: false, error: 'Failed to add password.' };
         }
     }, [resolveCloudAuthUrl, cloudAuthConfigured]);
+    const changePassword = useCallback(async (currentPassword, newPassword) => {
+        if (!cloudAuthConfigured)
+            return { success: false, error: 'Cloud auth not configured.' };
+        try {
+            const res = await fetch(resolveCloudAuthUrl('/api/taskforce/auth/password/change'), {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                credentials: 'include',
+                body: JSON.stringify({ currentPassword, newPassword })
+            });
+            const data = await res.json().catch(() => ({}));
+            if (!res.ok || !data?.success) {
+                return { success: false, error: data?.error || 'Failed to change password.', code: data?.code };
+            }
+            await checkAuthSession({ force: true });
+            dispatchTaskforceAuthSessionChanged();
+            return { success: true };
+        }
+        catch {
+            return { success: false, error: 'Failed to change password.' };
+        }
+    }, [resolveCloudAuthUrl, cloudAuthConfigured, checkAuthSession]);
     const beginOAuthLink = useCallback((provider, returnTo) => {
         const sanitizedReturnTo = returnTo && /^\/[A-Za-z0-9_\-./?=&%]*$/.test(returnTo)
             ? returnTo
@@ -2468,13 +2673,12 @@ export function useTaskforce({ config = {}, initialTaskId, onTaskCountChange, on
     const resetCloudLogoutClientState = useCallback(() => {
         abortWorkspaceScopedRequests();
         referenceDataRequestRef.current = null;
-        lastLoadedUiStateKeyRef.current = '';
         lastAssigneeOptionsLoadKeyRef.current = '';
         lastConfigRefreshKeyRef.current = '';
         lastWorkspaceSyncStateLoadKeyRef.current = '';
         lastTaskSurfaceLoadKeyRef.current = '';
         lastSettingsSurfaceLoadKeyRef.current = '';
-        setUiStateReady(false);
+        resetPersistedUiStateLoad({ clearLoaded: true });
         setReferenceDataLoaded(false);
         setAssigneeOptions(createDefaultAssigneeOptions());
         setAssigneeOptionsLoaded(false);
@@ -2484,16 +2688,9 @@ export function useTaskforce({ config = {}, initialTaskId, onTaskCountChange, on
         setInitiatives([]);
         setWorkstreams([]);
         setPlanningBootstrapTaskSummaries([]);
+        setPlanningLoadState(createInitialPlanningLoadState());
         setLoadingTasks(false);
-        if (cloudRealtimeFollowUpRefreshTimerRef.current !== null && typeof window !== 'undefined') {
-            window.clearTimeout(cloudRealtimeFollowUpRefreshTimerRef.current);
-            cloudRealtimeFollowUpRefreshTimerRef.current = null;
-        }
-        if (archiveBootstrapTimerRef.current !== null && typeof window !== 'undefined') {
-            window.clearTimeout(archiveBootstrapTimerRef.current);
-            archiveBootstrapTimerRef.current = null;
-        }
-    }, [abortWorkspaceScopedRequests, setArchivedTasks, setTasks]);
+    }, [abortWorkspaceScopedRequests, resetPersistedUiStateLoad, setArchivedTasks, setTasks]);
     const logout = useCallback(async () => {
         try {
             if (cloudAuthConfigured) {
@@ -2529,7 +2726,7 @@ export function useTaskforce({ config = {}, initialTaskId, onTaskCountChange, on
             setSetupState(null);
             setBootstrapPhase('idle');
             setBootstrapError(null);
-            hasLoadedUiStateRef.current = false;
+            resetPersistedUiStateLoad({ clearLoaded: true });
             if (runtimeMode !== 'local') {
                 clearPersistedWorkspaceId(workspaceSelectionScope);
             }
@@ -2565,29 +2762,64 @@ export function useTaskforce({ config = {}, initialTaskId, onTaskCountChange, on
         fetchTasks,
         resetCloudLogoutClientState
     ]);
+    const initiativeTemplateOperationRef = useRef(null);
+    const runInitiativeMutation = useCallback(async (url, init, operationIdOverride) => {
+        if (!globalThis.crypto?.randomUUID)
+            throw new Error('Secure initiative operation identity generation is unavailable.');
+        const operationId = operationIdOverride || `operation-${globalThis.crypto.randomUUID()}`;
+        const requestInit = {
+            ...init,
+            headers: { ...(init.headers || {}), 'x-taskforce-operation-id': operationId },
+        };
+        try {
+            return await fetch(url, requestInit);
+        }
+        catch {
+            return fetch(url, requestInit);
+        }
+    }, []);
+    const workstreamHttpMutationClient = useMemo(() => createCloudWorkstreamHttpMutationClient(), []);
     const createInitiativeFromTemplate = useCallback(async (payload) => {
         try {
-            const res = await fetch('/api/taskforce/initiative-templates/create', {
+            const requestBody = JSON.stringify(payload);
+            if (initiativeTemplateOperationRef.current?.requestBody !== requestBody) {
+                if (!globalThis.crypto?.randomUUID) {
+                    throw new Error('Secure initiative operation identity generation is unavailable.');
+                }
+                initiativeTemplateOperationRef.current = {
+                    requestBody,
+                    operationId: `operation-${globalThis.crypto.randomUUID()}`,
+                };
+            }
+            const res = await runInitiativeMutation('/api/taskforce/initiative-templates/create', {
                 method: 'POST',
                 headers: { 'Content-Type': 'application/json' },
-                body: JSON.stringify(payload)
-            });
+                body: requestBody
+            }, initiativeTemplateOperationRef.current.operationId);
             const data = await res.json().catch(() => ({}));
             if (!res.ok || !data?.success) {
                 return { success: false, error: data?.error || `Create failed (${res.status})` };
             }
+            initiativeTemplateOperationRef.current = null;
             await fetchTasks(true);
             return { success: true, result: data?.results };
         }
         catch (error) {
             return { success: false, error: error.message };
         }
-    }, [fetchTasks]);
+    }, [fetchTasks, runInitiativeMutation]);
     const createInitiative = useCallback(async (payload) => {
-        const res = await fetch('/api/taskforce/initiative', {
+        if (!globalThis.crypto?.randomUUID)
+            throw new Error('Secure initiative identity generation is unavailable.');
+        const stablePayload = {
+            ...(payload || {}),
+            id: payload?.id || `initiative-${globalThis.crypto.randomUUID()}`,
+            createdAt: payload?.createdAt || new Date().toISOString(),
+        };
+        const res = await runInitiativeMutation('/api/taskforce/initiative', {
             method: 'POST',
             headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify(payload || {})
+            body: JSON.stringify(stablePayload)
         });
         const data = await res.json().catch(() => ({}));
         if (!res.ok) {
@@ -2596,9 +2828,9 @@ export function useTaskforce({ config = {}, initialTaskId, onTaskCountChange, on
         await fetchPlanningEntities();
         setInitiatives((current) => upsertEntityById(current, data));
         return data;
-    }, [fetchPlanningEntities]);
+    }, [fetchPlanningEntities, runInitiativeMutation]);
     const updateInitiative = useCallback(async (id, payload) => {
-        const res = await fetch(`/api/taskforce/initiative/${encodeURIComponent(id)}`, {
+        const res = await runInitiativeMutation(`/api/taskforce/initiative/${encodeURIComponent(id)}`, {
             method: 'PATCH',
             headers: { 'Content-Type': 'application/json' },
             body: JSON.stringify(payload || {})
@@ -2610,12 +2842,30 @@ export function useTaskforce({ config = {}, initialTaskId, onTaskCountChange, on
         await fetchPlanningEntities();
         setInitiatives((current) => upsertEntityById(current, data));
         return data;
-    }, [fetchPlanningEntities]);
+    }, [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]);
     const archiveInitiative = useCallback(async (id) => {
-        const res = await fetch(`/api/taskforce/initiative/${encodeURIComponent(id)}/archive`, {
+        const res = await runInitiativeMutation(`/api/taskforce/initiative/${encodeURIComponent(id)}/archive`, {
             method: 'POST',
         });
         const data = await res.json().catch(() => ({}));
@@ -2625,9 +2875,9 @@ export function useTaskforce({ config = {}, initialTaskId, onTaskCountChange, on
         setInitiatives((current) => upsertEntityById(current, data));
         refreshPlanningEntitiesInBackground();
         return data;
-    }, [refreshPlanningEntitiesInBackground]);
+    }, [refreshPlanningEntitiesInBackground, runInitiativeMutation]);
     const unarchiveInitiative = useCallback(async (id) => {
-        const res = await fetch(`/api/taskforce/initiative/${encodeURIComponent(id)}/unarchive`, {
+        const res = await runInitiativeMutation(`/api/taskforce/initiative/${encodeURIComponent(id)}/unarchive`, {
             method: 'POST',
         });
         const data = await res.json().catch(() => ({}));
@@ -2637,59 +2887,149 @@ export function useTaskforce({ config = {}, initialTaskId, onTaskCountChange, on
         setInitiatives((current) => upsertEntityById(current, data));
         refreshPlanningEntitiesInBackground();
         return data;
-    }, [refreshPlanningEntitiesInBackground]);
+    }, [refreshPlanningEntitiesInBackground, runInitiativeMutation]);
     const createWorkstream = useCallback(async (payload) => {
-        const res = await fetch('/api/taskforce/workstream', {
+        const attempt = await workstreamHttpMutationClient.prepareCreate(currentWorkspaceIdRef.current || 'default', (payload || {}));
+        const res = await fetchWorkstreamHttpMutation('/api/taskforce/workstream', {
             method: 'POST',
             headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify(payload || {})
-        });
+            body: JSON.stringify(attempt.body)
+        }, attempt.operationId);
+        const conclusiveRejection = !res.ok && await isConclusiveWorkstreamHttpResponse(res);
         const data = await res.json().catch(() => ({}));
         if (!res.ok) {
-            throw new Error(data?.error || `Failed to create workstream (${res.status})`);
+            if (conclusiveRejection) {
+                await workstreamHttpMutationClient.abandonCreate(attempt.fingerprint, attempt.operationId);
+            }
+            const retryGuidance = data?.retryAt ? ` Retry after ${data.retryAt}.` : '';
+            throw new Error(`${data?.error || `Failed to create workstream (${res.status})`}${retryGuidance}`);
         }
+        if (data?.id !== attempt.body.id)
+            throw new Error('Created workstream identity did not match the retained request identity.');
+        await workstreamHttpMutationClient.confirmCreate(attempt.fingerprint, attempt.operationId);
         await fetchPlanningEntities();
-        setWorkstreams((current) => upsertEntityById(current, data));
+        setWorkstreams((current) => {
+            const created = selectCreatedWorkstreamAfterRefresh(current, data);
+            return created ? upsertEntityById(current, created) : current;
+        });
         return data;
-    }, [fetchPlanningEntities]);
+    }, [currentWorkspaceIdRef, fetchPlanningEntities, workstreamHttpMutationClient]);
     const updateWorkstream = useCallback(async (id, payload) => {
-        const res = await fetch(`/api/taskforce/workstream/${encodeURIComponent(id)}`, {
+        const url = `/api/taskforce/workstream/${encodeURIComponent(id)}`;
+        const body = (payload || {});
+        const observed = workstreams.find((workstream) => workstream.id === id);
+        const observedState = observed ? {
+            updatedAt: observed.updatedAt || null,
+            initiativeId: observed.initiativeId || null,
+            ownerId: observed.ownerId || null,
+            isArchived: Boolean(observed.isArchived),
+        } : null;
+        const attempt = await workstreamHttpMutationClient.prepareMutation(currentWorkspaceIdRef.current || 'default', url, body, observedState);
+        const res = await fetchWorkstreamHttpMutation(url, {
             method: 'PATCH',
             headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify(payload || {})
-        });
+            body: JSON.stringify(body)
+        }, attempt.operationId);
+        const conclusiveRejection = !res.ok && await isConclusiveWorkstreamHttpResponse(res);
         const data = await res.json().catch(() => ({}));
         if (!res.ok) {
-            throw new Error(data?.error || `Failed to update workstream (${res.status})`);
+            if (conclusiveRejection) {
+                await workstreamHttpMutationClient.abandonMutation(attempt.fingerprint, attempt.operationId);
+            }
+            const retryGuidance = data?.retryAt ? ` Retry after ${data.retryAt}.` : '';
+            throw new Error(`${data?.error || `Failed to update workstream (${res.status})`}${retryGuidance}`);
         }
+        if (data?.id !== id)
+            throw new Error('Updated workstream identity did not match the requested workstream.');
+        await workstreamHttpMutationClient.confirmMutation(attempt.fingerprint, attempt.operationId);
         await fetchPlanningEntities();
         setWorkstreams((current) => upsertEntityById(current, data));
         return data;
-    }, [fetchPlanningEntities]);
+    }, [currentWorkspaceIdRef, fetchPlanningEntities, workstreamHttpMutationClient, workstreams]);
+    const reorderWorkstreamTasks = useCallback(async (workstreamId, taskIds) => {
+        const url = `/api/taskforce/workstream/${encodeURIComponent(workstreamId)}/task-order`;
+        const body = { taskIds };
+        const observed = workstreams.find((workstream) => workstream.id === workstreamId);
+        const attempt = await workstreamHttpMutationClient.prepareMutation(currentWorkspaceIdRef.current || 'default', url, body, {
+            updatedAt: observed?.updatedAt || null,
+            workstreamId,
+        });
+        const res = await fetchWorkstreamHttpMutation(url, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(body),
+        }, attempt.operationId);
+        const conclusiveRejection = !res.ok && await isConclusiveWorkstreamHttpResponse(res);
+        const data = await res.json().catch(() => ({}));
+        if (!res.ok) {
+            if (conclusiveRejection) {
+                await workstreamHttpMutationClient.abandonMutation(attempt.fingerprint, attempt.operationId);
+            }
+            const retryGuidance = data?.retryAt ? ` Retry after ${data.retryAt}.` : '';
+            throw new Error(`${data?.error || `Failed to reorder workstream tasks (${res.status})`}${retryGuidance}`);
+        }
+        if (data?.workstreamId !== workstreamId || !Array.isArray(data?.taskIds)) {
+            throw new Error('Reordered workstream task response did not match the request.');
+        }
+        await workstreamHttpMutationClient.confirmMutation(attempt.fingerprint, attempt.operationId);
+        const orderById = new Map(data.taskIds.map((taskId, index) => [taskId, (index + 1) * 1024]));
+        setTasks((current) => current.map((task) => orderById.has(task.id)
+            ? { ...task, workstreamOrder: orderById.get(task.id) }
+            : task));
+        await fetchPlanningEntities();
+    }, [currentWorkspaceIdRef, fetchPlanningEntities, workstreamHttpMutationClient, workstreams]);
     const archiveWorkstream = useCallback(async (id) => {
-        const res = await fetch(`/api/taskforce/workstream/${encodeURIComponent(id)}/archive`, {
+        const url = `/api/taskforce/workstream/${encodeURIComponent(id)}/archive`;
+        const observed = workstreams.find((workstream) => workstream.id === id);
+        const attempt = await workstreamHttpMutationClient.prepareMutation(currentWorkspaceIdRef.current || 'default', url, {}, observed ? {
+            updatedAt: observed.updatedAt || null,
+            isArchived: Boolean(observed.isArchived),
+        } : null);
+        const res = await fetchWorkstreamHttpMutation(url, {
             method: 'POST',
-        });
+        }, attempt.operationId);
+        const conclusiveRejection = !res.ok && await isConclusiveWorkstreamHttpResponse(res);
         const data = await res.json().catch(() => ({}));
         if (!res.ok) {
-            throw new Error(data?.error || `Failed to archive workstream (${res.status})`);
+            if (conclusiveRejection) {
+                await workstreamHttpMutationClient.abandonMutation(attempt.fingerprint, attempt.operationId);
+            }
+            const retryGuidance = data?.retryAt ? ` Retry after ${data.retryAt}.` : '';
+            throw new Error(`${data?.error || `Failed to archive workstream (${res.status})`}${retryGuidance}`);
         }
+        if (data?.id !== id)
+            throw new Error('Archived workstream identity did not match the requested workstream.');
+        await workstreamHttpMutationClient.confirmMutation(attempt.fingerprint, attempt.operationId);
         await fetchPlanningEntities();
         setWorkstreams((current) => upsertEntityById(current, data));
         return data;
-    }, [fetchPlanningEntities]);
+    }, [currentWorkspaceIdRef, fetchPlanningEntities, workstreamHttpMutationClient, workstreams]);
     const unarchiveWorkstream = useCallback(async (id) => {
-        const res = await fetch(`/api/taskforce/workstream/${encodeURIComponent(id)}/unarchive`, {
+        const url = `/api/taskforce/workstream/${encodeURIComponent(id)}/unarchive`;
+        const observed = workstreams.find((workstream) => workstream.id === id);
+        const attempt = await workstreamHttpMutationClient.prepareMutation(currentWorkspaceIdRef.current || 'default', url, {}, observed ? {
+            updatedAt: observed.updatedAt || null,
+            isArchived: Boolean(observed.isArchived),
+        } : null);
+        const res = await fetchWorkstreamHttpMutation(url, {
             method: 'POST',
-        });
+        }, attempt.operationId);
+        const conclusiveRejection = !res.ok && await isConclusiveWorkstreamHttpResponse(res);
         const data = await res.json().catch(() => ({}));
         if (!res.ok) {
-            throw new Error(data?.error || `Failed to unarchive workstream (${res.status})`);
+            if (conclusiveRejection) {
+                await workstreamHttpMutationClient.abandonMutation(attempt.fingerprint, attempt.operationId);
+            }
+            const retryGuidance = data?.retryAt ? ` Retry after ${data.retryAt}.` : '';
+            throw new Error(`${data?.error || `Failed to unarchive workstream (${res.status})`}${retryGuidance}`);
         }
+        if (data?.id !== id)
+            throw new Error('Unarchived workstream identity did not match the requested workstream.');
+        await workstreamHttpMutationClient.confirmMutation(attempt.fingerprint, attempt.operationId);
         await fetchPlanningEntities();
         setWorkstreams((current) => upsertEntityById(current, data));
         return data;
-    }, [fetchPlanningEntities]);
+    }, [currentWorkspaceIdRef, fetchPlanningEntities, workstreamHttpMutationClient, workstreams]);
     // Initialize auth once, then bootstrap protected data once auth gates are settled.
     const hasInitializedAuthRef = useRef(false);
     useEffect(() => {
@@ -2765,23 +3105,63 @@ export function useTaskforce({ config = {}, initialTaskId, onTaskCountChange, on
             onTaskCountChange(tasks.length);
         }
     }, [tasks.length, onTaskCountChange]);
-    const handledInitialTaskIdRef = useRef(null);
-    // Deep linking handler
+    const deepLinkRouteKey = useMemo(() => {
+        const taskId = String(initialTaskId || '').trim();
+        if (!taskId)
+            return '';
+        return [
+            String(requestedWorkspaceId || '').trim(),
+            taskId,
+            String(initialActivityEntryId || '').trim()
+        ].join(':');
+    }, [initialActivityEntryId, initialTaskId, requestedWorkspaceId]);
+    const deepLinkRouteKeyRef = useRef(deepLinkRouteKey);
+    deepLinkRouteKeyRef.current = deepLinkRouteKey;
+    const handledDeepLinkRouteKeyRef = useRef(null);
+    const failedDeepLinkRouteKeyRef = useRef(null);
+    const deepLinkWorkspaceSwitchRef = useRef(null);
+    const deepLinkFailureNoticeOwnerKeyRef = useRef(null);
+    const deepLinkCollectionLookupRef = useRef(null);
+    const deepLinkArchiveSettledRef = useRef(new Set());
+    const deepLinkDeletedSettledRef = useRef(new Set());
+    const deepLinkRetryCountsRef = useRef(new Map());
+    const deepLinkRetryTimerRef = useRef(null);
+    const deepLinkWorkspaceSwitchRetryTimerRef = useRef(null);
+    const [deepLinkRetryNonce, setDeepLinkRetryNonce] = useState(0);
     useEffect(() => {
-        if (!initialTaskId) {
-            handledInitialTaskIdRef.current = null;
-            return;
-        }
-        if (handledInitialTaskIdRef.current === initialTaskId || tasks.length === 0) {
-            return;
-        }
-        const task = tasks.find(t => t.id.endsWith(initialTaskId) || t.id === initialTaskId);
-        if (task) {
-            handledInitialTaskIdRef.current = initialTaskId;
-            handleEdit(task);
-            setActiveTab('add');
+        const previousFailureNoticeOwnerKey = deepLinkFailureNoticeOwnerKeyRef.current;
+        if (previousFailureNoticeOwnerKey
+            && uiNoticeRef.current?.ownerKey === previousFailureNoticeOwnerKey) {
+            clearNotice();
+        }
+        deepLinkFailureNoticeOwnerKeyRef.current = null;
+        handledDeepLinkRouteKeyRef.current = null;
+        failedDeepLinkRouteKeyRef.current = null;
+        deepLinkWorkspaceSwitchRef.current = null;
+        deepLinkCollectionLookupRef.current = null;
+        deepLinkArchiveSettledRef.current.clear();
+        deepLinkDeletedSettledRef.current.clear();
+        deepLinkRetryCountsRef.current.clear();
+        if (deepLinkRetryTimerRef.current !== null && typeof window !== 'undefined') {
+            window.clearTimeout(deepLinkRetryTimerRef.current);
+            deepLinkRetryTimerRef.current = null;
+        }
+        if (deepLinkWorkspaceSwitchRetryTimerRef.current !== null && typeof window !== 'undefined') {
+            window.clearTimeout(deepLinkWorkspaceSwitchRetryTimerRef.current);
+            deepLinkWorkspaceSwitchRetryTimerRef.current = null;
+        }
+        setDeepLinkRetryNonce((current) => current + 1);
+    }, [clearNotice, deepLinkRouteKey]);
+    useEffect(() => () => {
+        if (deepLinkRetryTimerRef.current !== null && typeof window !== 'undefined') {
+            window.clearTimeout(deepLinkRetryTimerRef.current);
+            deepLinkRetryTimerRef.current = null;
+        }
+        if (deepLinkWorkspaceSwitchRetryTimerRef.current !== null && typeof window !== 'undefined') {
+            window.clearTimeout(deepLinkWorkspaceSwitchRetryTimerRef.current);
+            deepLinkWorkspaceSwitchRetryTimerRef.current = null;
         }
-    }, [initialTaskId, tasks]);
+    }, []);
     // Update active category logic
     const hasInitedCategoryRef = useRef(false);
     useEffect(() => {
@@ -2807,7 +3187,7 @@ export function useTaskforce({ config = {}, initialTaskId, onTaskCountChange, on
     }, [configLoaded, activeCategories, category, getPreferredCategoryValue, lastUsedCategory]);
     // Sanitize tasks with invalid categories
     useEffect(() => {
-        if (!configLoaded || activeCategories.length === 0)
+        if (!configLoaded || !referenceDataLoaded || activeCategories.length === 0)
             return;
         const needsSanitization = (t) => {
             return !activeCategories.some(c => c.value === t.category);
@@ -2824,31 +3204,38 @@ export function useTaskforce({ config = {}, initialTaskId, onTaskCountChange, on
                 setArchivedTasks(prev => prev.map(t => needsSanitization(t) ? { ...t, category: defaultCategory } : t));
             }
         }
-    }, [configLoaded, activeCategories, tasks, archivedTasks, getPreferredCategoryValue]);
-    useEffect(() => {
-        return () => {
-            if (archiveBootstrapTimerRef.current !== null && typeof window !== 'undefined') {
-                window.clearTimeout(archiveBootstrapTimerRef.current);
-                archiveBootstrapTimerRef.current = null;
-            }
-            if (cloudRealtimeFollowUpRefreshTimerRef.current !== null && typeof window !== 'undefined') {
-                window.clearTimeout(cloudRealtimeFollowUpRefreshTimerRef.current);
-                cloudRealtimeFollowUpRefreshTimerRef.current = null;
-            }
-        };
-    }, []);
+    }, [configLoaded, referenceDataLoaded, activeCategories, tasks, archivedTasks, getPreferredCategoryValue]);
     // HMR Listener for Real-Time Updates
     useEffect(() => {
         if (import.meta.hot) {
             import.meta.hot.on('taskforce:update', () => {
                 // console.log('[Taskforce] Received HMR update, refreshing data...');
-                void refreshTaskCollections({ isSilent: true });
+                void refreshTaskCollections({ isSilent: true, highlightChangedTaskIds: [] });
             });
         }
     }, [refreshTaskCollections]);
     const refreshTaskCollectionsForDataVersion = useCallback(async () => {
-        await refreshTaskCollectionsFromInvalidation();
+        await refreshTaskCollectionsFromInvalidation(createTaskInvalidationScope(['active', 'archive', 'deleted', 'planning'], { ambiguous: true }));
     }, [refreshTaskCollectionsFromInvalidation]);
+    useEffect(() => {
+        if (typeof window === 'undefined')
+            return;
+        const handleTaskforceTasksMutated = (event) => {
+            const detail = event.detail;
+            const eventWorkspaceId = String(detail?.workspaceId || '').trim() || 'default';
+            if (eventWorkspaceId !== currentWorkspaceId)
+                return;
+            if (detail?.authoritativeTask)
+                return;
+            void refreshTaskCollectionsFromInvalidation(createTaskInvalidationScope(detail?.affectedCollections?.length
+                ? detail.affectedCollections
+                : ['active', 'archive'], { taskIds: detail?.taskId ? [detail.taskId] : [] }));
+        };
+        window.addEventListener(TASKFORCE_TASKS_MUTATED_EVENT, handleTaskforceTasksMutated);
+        return () => {
+            window.removeEventListener(TASKFORCE_TASKS_MUTATED_EVENT, handleTaskforceTasksMutated);
+        };
+    }, [currentWorkspaceId, refreshTaskCollectionsFromInvalidation]);
     const normalizedRealtimeWorkspaceId = String(currentWorkspaceId || '').trim();
     const normalizedRealtimeUserId = String(authUserId || '').trim();
     const realtimeSocketUrl = resolveWebSocketUrl('/taskforce-ws');
@@ -2861,23 +3248,35 @@ export function useTaskforce({ config = {}, initialTaskId, onTaskCountChange, on
         && normalizedRealtimeWorkspaceId
         && !isReservedWorkspaceId(normalizedRealtimeWorkspaceId)
         && realtimeSocketUrl);
-    const handleCloudRealtimeSignal = useCallback(() => {
+    useEffect(() => {
+        return () => {
+            if (ambiguousRealtimeConfirmationTimerRef.current !== null && typeof window !== 'undefined') {
+                window.clearTimeout(ambiguousRealtimeConfirmationTimerRef.current);
+                ambiguousRealtimeConfirmationTimerRef.current = null;
+            }
+        };
+    }, [currentWorkspaceId]);
+    const handleCloudRealtimeSignal = useCallback((signal) => {
         if (runtimeMode !== 'cloud')
             return;
-        void refreshTaskCollectionsFromInvalidation();
-        if (typeof window === 'undefined')
+        dispatchTaskforceWorkspaceResourcesInvalidated({
+            workspaceId: normalizedRealtimeWorkspaceId,
+            source: 'realtime',
+        });
+        const scope = resolveRealtimeTaskInvalidation(signal.type, signal.invalidations);
+        if (scope.collections.length === 0)
             return;
-        if (cloudRealtimeFollowUpRefreshTimerRef.current !== null) {
-            window.clearTimeout(cloudRealtimeFollowUpRefreshTimerRef.current);
-        }
-        // Cloud invalidation events can arrive while the originating push/apply request
-        // is still unwinding. A short follow-up refresh closes that race without turning
-        // the websocket layer into a full data transport.
-        cloudRealtimeFollowUpRefreshTimerRef.current = window.setTimeout(() => {
-            cloudRealtimeFollowUpRefreshTimerRef.current = null;
-            void refreshTaskCollectionsFromInvalidation();
+        void refreshTaskCollectionsFromInvalidation(scope);
+        if (!scope.ambiguous || typeof window === 'undefined')
+            return;
+        if (ambiguousRealtimeConfirmationTimerRef.current !== null) {
+            window.clearTimeout(ambiguousRealtimeConfirmationTimerRef.current);
+        }
+        ambiguousRealtimeConfirmationTimerRef.current = window.setTimeout(() => {
+            ambiguousRealtimeConfirmationTimerRef.current = null;
+            void refreshTaskCollectionsFromInvalidation(scope);
         }, 250);
-    }, [runtimeMode, refreshTaskCollectionsFromInvalidation]);
+    }, [normalizedRealtimeWorkspaceId, runtimeMode, refreshTaskCollectionsFromInvalidation]);
     useRealtimeSync({
         enabled: cloudRealtimeEnabled,
         workspaceId: normalizedRealtimeWorkspaceId,
@@ -2887,6 +3286,7 @@ export function useTaskforce({ config = {}, initialTaskId, onTaskCountChange, on
     });
     // Fallback sync for cross-process writes (e.g., MCP tools) that may miss watcher/websocket events.
     useDataVersionRefresh({
+        workspaceId: currentWorkspaceId,
         isOpen,
         authBlocked,
         authRequiredForApi,
@@ -2897,7 +3297,8 @@ export function useTaskforce({ config = {}, initialTaskId, onTaskCountChange, on
         authRequiredForApiRef,
         isAuthenticatedRef,
         dataVersionRef,
-        refreshTaskCollectionsForDataVersion
+        refreshTaskCollectionsForDataVersion,
+        coordinatorDataVersion: localCoordinatorDataVersion,
     });
     const relationshipTasks = useMemo(() => {
         const byId = new Map();
@@ -2922,21 +3323,31 @@ export function useTaskforce({ config = {}, initialTaskId, onTaskCountChange, on
             return;
         if (activeTab === 'tasks') {
             const loadKey = `${currentWorkspaceId}:${activeTab}:${showArchive ? 'archive' : 'active'}:${taskScope}`;
+            const requiresArchive = showArchive || taskScope === 'archived';
+            const requiresDeleted = taskScope === 'deleted';
             if (!skippedInitialTaskTabRefreshRef.current) {
                 skippedInitialTaskTabRefreshRef.current = true;
                 lastTaskSurfaceLoadKeyRef.current = loadKey;
+                if (requiresArchive) {
+                    void ensureArchiveHydrated(false);
+                }
+                if (requiresDeleted) {
+                    void ensureDeletedTasksHydrated(false);
+                }
                 return;
             }
             if (lastTaskSurfaceLoadKeyRef.current === loadKey)
                 return;
             lastTaskSurfaceLoadKeyRef.current = loadKey;
-            fetchTasks();
+            if (!requiresArchive && !requiresDeleted) {
+                fetchTasks();
+            }
             fetchPlanningEntities();
-            if (showArchive || taskScope === 'archived') {
-                fetchArchive(true);
+            if (requiresArchive) {
+                void ensureArchiveHydrated(false);
             }
-            if (taskScope === 'deleted') {
-                fetchDeletedTasks();
+            if (requiresDeleted) {
+                void ensureDeletedTasksHydrated(false);
             }
             return;
         }
@@ -2946,9 +3357,6 @@ export function useTaskforce({ config = {}, initialTaskId, onTaskCountChange, on
                 return;
             lastSettingsSurfaceLoadKeyRef.current = loadKey;
             fetchConfig();
-            if (settingsSection === 'commands' || settingsSection === 'resources') {
-                fetchWorkflows();
-            }
         }
     }, [
         currentWorkspaceId,
@@ -2959,10 +3367,9 @@ export function useTaskforce({ config = {}, initialTaskId, onTaskCountChange, on
         taskScope,
         fetchTasks,
         fetchPlanningEntities,
-        fetchArchive,
-        fetchDeletedTasks,
+        ensureArchiveHydrated,
+        ensureDeletedTasksHydrated,
         fetchConfig,
-        fetchWorkflows,
         shouldDeferProtectedApiCalls,
         shouldBlockProtectedApiCalls,
         workspaceBootstrapPending
@@ -3055,7 +3462,7 @@ export function useTaskforce({ config = {}, initialTaskId, onTaskCountChange, on
         }
         setActiveTab__internal(tab);
     }, [activeTab]);
-    const flushAutoSaveRef = useRef(async () => { });
+    const flushAutoSaveRef = useRef(async () => true);
     const { handleNavigation, handleClose, resetForm, resolveTaskIdInput, resolveWorkstreamIdInput, handleEdit, handleOpenTaskById, returnToPreviousTask, clearReturnToParentTask } = useTaskEditorNavigation({
         activeCategories,
         activeTypes,
@@ -3066,7 +3473,9 @@ export function useTaskforce({ config = {}, initialTaskId, onTaskCountChange, on
         description,
         editingTaskId,
         flushPendingAutoSave: () => flushAutoSaveRef.current(),
+        getDescriptionDraft,
         getPreferredCategoryValue,
+        getTitleDraft,
         lastUsedCategory,
         newCommentText,
         relationshipTasks,
@@ -3074,7 +3483,6 @@ export function useTaskforce({ config = {}, initialTaskId, onTaskCountChange, on
         showArchive,
         taxonomies,
         setActiveTab,
-        setApproach,
         setAssignee,
         setAttachments,
         setAttachmentsDirty,
@@ -3102,9 +3510,302 @@ export function useTaskforce({ config = {}, initialTaskId, onTaskCountChange, on
         taskReturnTrail,
         title,
     });
+    useEffect(() => {
+        const normalizedTaskId = String(pendingOpenTaskId || '').trim();
+        if (!uiStateReady || !normalizedTaskId)
+            return;
+        if (editingTaskId === normalizedTaskId) {
+            setPendingOpenTaskId(null);
+            return;
+        }
+        if (loadingTasks || workspaceBootstrapPending)
+            return;
+        const matchesTask = (task) => (task.id === normalizedTaskId || task.id.endsWith(normalizedTaskId));
+        const target = relationshipTasks.find(matchesTask);
+        if (target) {
+            handleOpenTaskById(normalizedTaskId);
+            setPendingOpenTaskId(null);
+            return;
+        }
+        const workspaceId = String(currentWorkspaceIdRef.current || 'default').trim() || 'default';
+        const archiveLookupKey = `${workspaceId}:${normalizedTaskId}`;
+        if (archiveHydratedWorkspaceId !== workspaceId && !archiveLookupSettledKeys.has(archiveLookupKey)) {
+            void ensureArchiveHydrated(true).finally(() => {
+                const liveWorkspaceId = String(currentWorkspaceIdRef.current || 'default').trim() || 'default';
+                if (liveWorkspaceId === workspaceId) {
+                    setArchiveLookupSettledKeys((current) => {
+                        if (current.has(archiveLookupKey))
+                            return current;
+                        return new Set(current).add(archiveLookupKey);
+                    });
+                }
+            });
+            return;
+        }
+        const deletedTarget = deletedRelationshipTasks.find(matchesTask);
+        if (deletedTarget) {
+            handleEdit(deletedTarget);
+            setPendingOpenTaskId(null);
+            return;
+        }
+        if (deletedHydratedWorkspaceId !== workspaceId) {
+            void ensureDeletedTasksHydrated(true);
+            return;
+        }
+        setPendingOpenTaskId(null);
+    }, [
+        archiveHydratedWorkspaceId,
+        archiveLookupSettledKeys,
+        deletedHydratedWorkspaceId,
+        deletedRelationshipTasks,
+        editingTaskId,
+        ensureArchiveHydrated,
+        ensureDeletedTasksHydrated,
+        handleEdit,
+        handleOpenTaskById,
+        loadingTasks,
+        pendingOpenTaskId,
+        relationshipTasks,
+        uiStateReady,
+        workspaceBootstrapPending
+    ]);
+    // Deep links are workspace-scoped. In cloud mode, switch to the explicit
+    // workspace before looking up the task. Local runtimes never cross their
+    // configured workspace boundary.
+    useEffect(() => {
+        const normalizedTaskId = String(initialTaskId || '').trim();
+        if (!normalizedTaskId || !deepLinkRouteKey)
+            return;
+        if (handledDeepLinkRouteKeyRef.current === deepLinkRouteKey
+            || !runtimeConfigReady
+            || !configLoaded
+            || !uiStateReady
+            || loadingTasks
+            || workspaceBootstrapPending) {
+            return;
+        }
+        const explicitWorkspaceId = String(requestedWorkspaceId || '').trim();
+        const activeWorkspaceId = String(currentWorkspaceIdRef.current || 'default').trim() || 'default';
+        const clearOwnedFailureNotice = () => {
+            const ownerKey = deepLinkFailureNoticeOwnerKeyRef.current;
+            if (ownerKey && uiNoticeRef.current?.ownerKey === ownerKey) {
+                clearNotice();
+            }
+            deepLinkFailureNoticeOwnerKeyRef.current = null;
+        };
+        if (explicitWorkspaceId && explicitWorkspaceId !== activeWorkspaceId) {
+            if (failedDeepLinkRouteKeyRef.current === deepLinkRouteKey)
+                return;
+            if (runtimeMode !== 'cloud' || !workspaceSwitchingEnabled) {
+                if (failedDeepLinkRouteKeyRef.current !== deepLinkRouteKey) {
+                    failedDeepLinkRouteKeyRef.current = deepLinkRouteKey;
+                    pushNotice('This task is unavailable or you do not have access to it.', 'info', 12_000);
+                }
+                return;
+            }
+            if (!authSessionResolved || !isAuthenticated || authBlocked)
+                return;
+            if (deepLinkWorkspaceSwitchRef.current === deepLinkRouteKey
+                || deepLinkWorkspaceSwitchRetryTimerRef.current !== null) {
+                return;
+            }
+            const routeKeyAtStart = deepLinkRouteKey;
+            const switchRetryKey = `${routeKeyAtStart}:workspace`;
+            deepLinkWorkspaceSwitchRef.current = routeKeyAtStart;
+            void switchWorkspace(explicitWorkspaceId).then((result) => {
+                if (deepLinkRouteKeyRef.current !== routeKeyAtStart)
+                    return;
+                if (!result.success) {
+                    const attemptCount = (deepLinkRetryCountsRef.current.get(switchRetryKey) || 0) + 1;
+                    deepLinkRetryCountsRef.current.set(switchRetryKey, attemptCount);
+                    if (attemptCount < 2 && typeof window !== 'undefined') {
+                        deepLinkWorkspaceSwitchRetryTimerRef.current = window.setTimeout(() => {
+                            deepLinkWorkspaceSwitchRetryTimerRef.current = null;
+                            if (deepLinkRouteKeyRef.current === routeKeyAtStart) {
+                                setDeepLinkRetryNonce((current) => current + 1);
+                            }
+                        }, 500);
+                        return;
+                    }
+                    failedDeepLinkRouteKeyRef.current = routeKeyAtStart;
+                    const failureNoticeOwnerKey = `deep-link-workspace:${routeKeyAtStart}`;
+                    deepLinkFailureNoticeOwnerKeyRef.current = failureNoticeOwnerKey;
+                    pushNotice('This task is unavailable or you do not have access to it.', 'info', 12_000, {
+                        label: 'Retry',
+                        onAction: () => {
+                            if (deepLinkRouteKeyRef.current !== routeKeyAtStart)
+                                return;
+                            deepLinkFailureNoticeOwnerKeyRef.current = null;
+                            failedDeepLinkRouteKeyRef.current = null;
+                            deepLinkRetryCountsRef.current.delete(switchRetryKey);
+                            clearNotice();
+                            setDeepLinkRetryNonce((current) => current + 1);
+                        },
+                        ownerKey: failureNoticeOwnerKey
+                    });
+                }
+            }).finally(() => {
+                if (deepLinkWorkspaceSwitchRef.current === routeKeyAtStart) {
+                    deepLinkWorkspaceSwitchRef.current = null;
+                }
+            });
+            return;
+        }
+        const resolveTarget = (items) => {
+            const exact = items.find((task) => task.id === normalizedTaskId);
+            if (exact || explicitWorkspaceId)
+                return exact;
+            const legacySuffixMatches = items.filter((task) => task.id.endsWith(normalizedTaskId));
+            return legacySuffixMatches.length === 1 ? legacySuffixMatches[0] : undefined;
+        };
+        const target = resolveTarget(relationshipTasks);
+        if (target) {
+            clearOwnedFailureNotice();
+            handledDeepLinkRouteKeyRef.current = deepLinkRouteKey;
+            failedDeepLinkRouteKeyRef.current = null;
+            if (editingTaskId !== target.id) {
+                if (target.isArchived)
+                    setShowArchive(true);
+                handleEdit(target);
+            }
+            return;
+        }
+        const scheduleCollectionLookup = (collection, lookup, settledRoutes) => {
+            const lookupKey = `${deepLinkRouteKey}:${collection}`;
+            if (deepLinkCollectionLookupRef.current === lookupKey
+                || deepLinkRetryTimerRef.current !== null) {
+                return;
+            }
+            deepLinkCollectionLookupRef.current = lookupKey;
+            const routeKeyAtStart = deepLinkRouteKey;
+            void lookup().then((loaded) => {
+                if (deepLinkRouteKeyRef.current !== routeKeyAtStart)
+                    return;
+                if (loaded) {
+                    setDeepLinkRetryNonce((current) => current + 1);
+                    return;
+                }
+                const attemptCount = (deepLinkRetryCountsRef.current.get(lookupKey) || 0) + 1;
+                deepLinkRetryCountsRef.current.set(lookupKey, attemptCount);
+                if (attemptCount >= 2) {
+                    settledRoutes.add(routeKeyAtStart);
+                    setDeepLinkRetryNonce((current) => current + 1);
+                    return;
+                }
+                if (typeof window !== 'undefined') {
+                    deepLinkRetryTimerRef.current = window.setTimeout(() => {
+                        deepLinkRetryTimerRef.current = null;
+                        if (deepLinkRouteKeyRef.current === routeKeyAtStart) {
+                            setDeepLinkRetryNonce((current) => current + 1);
+                        }
+                    }, 500);
+                }
+            }).finally(() => {
+                if (deepLinkCollectionLookupRef.current === lookupKey) {
+                    deepLinkCollectionLookupRef.current = null;
+                }
+            });
+        };
+        if (archiveHydratedWorkspaceId !== activeWorkspaceId
+            && !deepLinkArchiveSettledRef.current.has(deepLinkRouteKey)) {
+            scheduleCollectionLookup('archive', () => ensureArchiveHydrated(true), deepLinkArchiveSettledRef.current);
+            return;
+        }
+        const deletedTarget = resolveTarget(deletedRelationshipTasks);
+        if (deletedTarget) {
+            clearOwnedFailureNotice();
+            handledDeepLinkRouteKeyRef.current = deepLinkRouteKey;
+            failedDeepLinkRouteKeyRef.current = null;
+            handleEdit(deletedTarget);
+            return;
+        }
+        if (deletedHydratedWorkspaceId !== activeWorkspaceId
+            && !deepLinkDeletedSettledRef.current.has(deepLinkRouteKey)) {
+            scheduleCollectionLookup('deleted', () => ensureDeletedTasksHydrated(true), deepLinkDeletedSettledRef.current);
+            return;
+        }
+        if (failedDeepLinkRouteKeyRef.current !== deepLinkRouteKey) {
+            failedDeepLinkRouteKeyRef.current = deepLinkRouteKey;
+            pushNotice('This task is unavailable or you do not have access to it.', 'info', 12_000);
+        }
+    }, [
+        archiveHydratedWorkspaceId,
+        authBlocked,
+        authSessionResolved,
+        clearNotice,
+        configLoaded,
+        currentWorkspaceIdRef,
+        deepLinkRetryNonce,
+        deepLinkRouteKey,
+        deletedHydratedWorkspaceId,
+        deletedRelationshipTasks,
+        editingTaskId,
+        ensureArchiveHydrated,
+        ensureDeletedTasksHydrated,
+        handleEdit,
+        initialTaskId,
+        isAuthenticated,
+        loadingTasks,
+        pushNotice,
+        relationshipTasks,
+        requestedWorkspaceId,
+        runtimeConfigReady,
+        runtimeMode,
+        setShowArchive,
+        switchWorkspace,
+        uiStateReady,
+        workspaceBootstrapPending,
+        workspaceSwitchingEnabled
+    ]);
     // === SECTION: Task CRUD ===
     // Pure mutation callbacks are managed by useTaskMutations.
-    const { copiedId, handleDelete, handleUpdateTask, handleToggleComplete, handleToggleCancel, handleToggleInProgress, handleToggleReview, handleArchiveTask, handleBulkArchive, handleUnarchive, handleRestoreDeletedTask, handlePermanentlyDeleteDeletedTask, handleEmptyDeletedTasks, handleCopyId, queueWorkspaceSyncFromAuthoritativeTaskState, } = useTaskActions({
+    const mutateTaskMetadata = useDurableTaskMetadataMutation({
+        enabled: runtimeConfigOverride.syncV3TaskMetadataActivation
+            && runtimeMode === 'local',
+        workspaceId: currentWorkspaceId,
+        isAuthenticated,
+        dispatchEnabled: workspaceCloudSyncEnabled,
+    });
+    const createTaskDurably = useDurableTaskCreateMutation({
+        localRuntime: runtimeMode === 'local',
+        enabled: runtimeConfigOverride.syncV3TaskCreateActivation
+            && runtimeMode === 'local',
+        workspaceId: currentWorkspaceId,
+        isAuthenticated,
+        dispatchEnabled: workspaceCloudSyncEnabled,
+    });
+    const taskStatusActivationEnabled = runtimeConfigOverride.syncV3TaskStatusActivation
+        && runtimeMode === 'local';
+    const mutateTaskStatus = useDurableTaskStatusMutation({
+        enabled: taskStatusActivationEnabled,
+        workspaceId: currentWorkspaceId,
+        isAuthenticated,
+        dispatchEnabled: workspaceCloudSyncEnabled,
+    });
+    const mutateTaskLifecycle = useDurableTaskLifecycleMutation({
+        // Always probe the local durable lifecycle boundary. The route returns
+        // an explicit disabled result for v2-owned workspaces, but persisted
+        // v3 ownership must survive a process restart with incomplete flags.
+        enabled: runtimeMode === 'local',
+        workspaceId: currentWorkspaceId,
+        isAuthenticated,
+        dispatchEnabled: workspaceCloudSyncEnabled,
+    });
+    const taskDeleteActivationEnabled = runtimeConfigOverride.syncV3TaskDeleteActivation
+        && runtimeMode === 'local';
+    const mutateTaskDelete = useDurableTaskDeleteMutation({
+        enabled: taskDeleteActivationEnabled,
+        workspaceId: currentWorkspaceId,
+        isAuthenticated,
+        dispatchEnabled: workspaceCloudSyncEnabled,
+    });
+    const mutateTaskRestore = useDurableTaskRestoreMutation({
+        enabled: taskDeleteActivationEnabled,
+        workspaceId: currentWorkspaceId,
+        isAuthenticated,
+        dispatchEnabled: workspaceCloudSyncEnabled,
+    });
+    const { copiedId, handleDelete, handleUpdateTask, handleSetStatus, handleToggleComplete, handleToggleCancel, handleToggleInProgress, handleToggleReview, handleArchiveTask, handleBulkArchive, handleUnarchive, handleRestoreDeletedTask, handleRestoreSelectedDeletedTasks, handlePermanentlyDeleteDeletedTask, handleEmptyDeletedTasks, handleCopyId, queueWorkspaceSyncFromAuthoritativeTaskState, } = useTaskActions({
         tasks,
         archivedTasks,
         editingTaskId,
@@ -3115,8 +3816,8 @@ export function useTaskforce({ config = {}, initialTaskId, onTaskCountChange, on
         resetForm,
         setActiveTab,
         fetchTasks,
-        fetchArchive,
-        fetchDeletedTasks,
+        fetchArchive: refreshArchiveIfHydrated,
+        fetchDeletedTasks: refreshDeletedTasksIfHydrated,
         mergeTaskFromServer,
         pushNotice,
         cloudAuthConfigured,
@@ -3128,12 +3829,38 @@ export function useTaskforce({ config = {}, initialTaskId, onTaskCountChange, on
         workspacePendingSignatureRef,
         workspaceDeletedTaskIdsRef,
         workspaceDeletedTaskWatermarksRef,
+        mutateTaskMetadata,
+        mutateTaskStatus,
+        mutateTaskLifecycle,
+        mutateTaskDelete,
+        mutateTaskRestore,
+        durableTaskMetadataActivationEnabled: runtimeConfigOverride.syncV3TaskMetadataActivation
+            && runtimeMode === 'local',
+        durableTaskStatusActivationEnabled: taskStatusActivationEnabled,
+        durableTaskDeleteActivationEnabled: taskDeleteActivationEnabled,
+        durableTaskHttpRootActivationEnabled: runtimeConfigOverride.syncV3TaskCloudHttpRootActivation,
+        workspaceId: currentWorkspaceId,
     });
+    const promoteDescriptionImageDraft = useCallback(async () => {
+        const draftId = descriptionImageDraftIdRef.current;
+        const response = await fetch('/api/taskforce/context-upload/draft/promote', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                workspaceId: currentWorkspaceId,
+                draftUploadId: draftId,
+                uploadPurpose: 'task-description-draft',
+            }),
+        });
+        if (!response.ok) {
+            throw new Error('Task was created, but its draft upload records could not be finalized.');
+        }
+        rotateDescriptionImageDraftId();
+    }, [currentWorkspaceId, rotateDescriptionImageDraftId]);
     const { autoSaveState, flushAutoSave, scheduleWarningPrompt, handleSubmit, confirmScheduleWarning, cancelScheduleWarning, handleAddComment } = useTaskFormActions({
         activeCategories,
         activeTab,
         apiEndpoint,
-        approach,
         assignee,
         attachments,
         attachmentsDirty,
@@ -3143,16 +3870,27 @@ export function useTaskforce({ config = {}, initialTaskId, onTaskCountChange, on
         complexity,
         description,
         dueDate,
+        createTaskDurably,
+        durableTaskHttpRootActivationEnabled: runtimeConfigOverride.syncV3TaskCloudHttpRootActivation,
+        workspaceId: currentWorkspaceId,
+        updateTask: handleUpdateTask,
         editingTaskId,
         fetchTasks,
         formTaxonomies,
+        getAttachmentsDraft,
+        getDescriptionDraft,
         getPreferredCategoryValue,
+        getTitleDraft,
+        awaitPendingDescriptionImageUpload,
+        onTaskCreateAccepted: promoteDescriptionImageDraft,
         mergeTaskFromServer,
+        onTaskCreated: handleEdit,
         workstreamInput,
         priority,
         pushNotice,
         queueWorkspaceSyncFromAuthoritativeTaskState,
         relationshipTasks,
+        supplementalTasks: deletedRelationshipTasks,
         resetForm,
         resolveWorkstreamIdInput,
         scheduledDate,
@@ -3166,28 +3904,53 @@ export function useTaskforce({ config = {}, initialTaskId, onTaskCountChange, on
         status,
         title,
         taxonomies,
+        textDraftOccupied,
         type
     });
+    const discardDescriptionImageDraft = useCallback(async () => {
+        const draftId = descriptionImageDraftIdRef.current;
+        rotateDescriptionImageDraftId();
+        try {
+            await awaitPendingDescriptionImageUpload();
+            const response = await fetch('/api/taskforce/context-upload/draft/discard', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    workspaceId: currentWorkspaceId,
+                    draftUploadId: draftId,
+                    uploadPurpose: 'task-description-draft',
+                }),
+            });
+            if (!response.ok)
+                throw new Error('Draft upload cleanup was rejected.');
+        }
+        catch (error) {
+            console.warn('[Taskforce] Failed to clean discarded Description image uploads.', error);
+        }
+    }, [awaitPendingDescriptionImageUpload, currentWorkspaceId, rotateDescriptionImageDraftId]);
     useEffect(() => {
         flushAutoSaveRef.current = flushAutoSave;
     }, [flushAutoSave]);
     const { handleSetWorkstreamForCurrentTask, } = useTaskRelationships({
         editingTaskId,
-        mergeTaskFromServer,
         workstreamInput,
         pushNotice,
-        queueWorkspaceSyncFromAuthoritativeTaskState,
         relationshipTasks,
         resolveWorkstreamIdInput,
         setError,
-        fetchTasks
+        updateTask: handleUpdateTask
     });
     const { currentTask, currentTaskWorkstream, currentTaskInitiative, } = useCurrentTaskRelations({
         editingTaskId,
         relationshipTasks,
         initiatives,
         workstreams,
+        workstreamInput,
+        resolveWorkstreamIdInput,
         supplementalTasks: deletedRelationshipTasks,
+        assignee,
+        setAssignee,
+        setChecklistItems,
         setComments
     });
     const settingsModel = useSettingsModel({
@@ -3211,12 +3974,8 @@ export function useTaskforce({ config = {}, initialTaskId, onTaskCountChange, on
         manualComplexityEnabled,
         checklistDropdownEnabled,
         showTaskCardStatusLabel,
-        exportWorkflowsPath,
-        exportingResource,
-        exportResult,
         pathSaved,
         settingsSection,
-        exportEnvironment,
         setupState,
         buildInfo,
         saveSetupMode,
@@ -3234,19 +3993,9 @@ export function useTaskforce({ config = {}, initialTaskId, onTaskCountChange, on
         handleShowTaskCardStatusLabelChange,
         handleResetProjectToGlobal,
         handleSaveSettings,
-        setExportWorkflowsPath,
-        setExportEnvironment,
-        availableWorkflows,
         initiativeTemplates,
-        availableEnvironments,
-        fetchWorkflows,
         fetchInitiativeTemplates,
         createInitiativeFromTemplate,
-        fetchWorkflowTemplate,
-        fetchWorkflowOverrideNames,
-        saveWorkflowTemplateDraft,
-        resetWorkflowTemplateDraft,
-        handleExportWorkflows,
         setShowFolderBrowser,
         setBrowserTarget,
         fetchFolders,
@@ -3403,6 +4152,8 @@ export function useTaskforce({ config = {}, initialTaskId, onTaskCountChange, on
         workspaceSyncRecommendedAction,
         workspaceSyncBusy,
         workspaceSyncPendingChanges,
+        localCoordinatorStatus,
+        transferLocalCoordinatorOwnership,
         retryUserGlobalSettingsSync,
         retryWorkspaceCloudSync,
         resetWorkspaceSyncCursorAndPull,
@@ -3439,6 +4190,7 @@ export function useTaskforce({ config = {}, initialTaskId, onTaskCountChange, on
         fetchLoginMethods,
         unlinkLoginMethod,
         addPasswordToAccount,
+        changePassword,
         beginOAuthLink,
         registerWithCredentials,
         updateCurrentUserProfile,
@@ -3470,15 +4222,17 @@ export function useTaskforce({ config = {}, initialTaskId, onTaskCountChange, on
         tasks,
         loadingTasks,
         archivedTasks,
+        archiveHydratedWorkspaceId,
         initiatives,
         workstreams,
         planningBootstrapTaskSummaries,
+        planningLoadState,
+        workspaceTaskRelationships,
         deletedTasks,
         activeCategories,
         activeTypes,
         priorities,
         taxonomyDisplayLabels,
-        approaches,
         taxonomies,
         // Filtering
         searchQuery,
@@ -3505,6 +4259,8 @@ export function useTaskforce({ config = {}, initialTaskId, onTaskCountChange, on
         setShowArchive,
         taskScope,
         setTaskScope,
+        compressedCards,
+        setCompressedCards,
         clearFilters,
         filteredTasks,
         searchAgnosticTasks,
@@ -3515,17 +4271,21 @@ export function useTaskforce({ config = {}, initialTaskId, onTaskCountChange, on
         // Actions
         fetchTasks,
         fetchArchive,
+        ensureArchiveHydrated,
         fetchDeletedTasks,
         fetchPlanningEntities,
+        fetchPlanningEntityDetail,
         fetchAssigneeOptions,
         createInitiative,
         updateInitiative,
+        updatePlanningIdentity,
         archiveInitiative,
         unarchiveInitiative,
         createWorkstream,
         updateWorkstream,
         archiveWorkstream,
         unarchiveWorkstream,
+        reorderWorkstreamTasks,
         handleEdit,
         handleDelete,
         handleCopyId,
@@ -3537,17 +4297,22 @@ export function useTaskforce({ config = {}, initialTaskId, onTaskCountChange, on
         handleBulkArchive,
         handleUnarchive,
         handleRestoreDeletedTask,
+        handleRestoreSelectedDeletedTasks,
         handlePermanentlyDeleteDeletedTask,
         handleEmptyDeletedTasks,
         handleUpdateTask,
+        handleSetStatus,
         // Form State
         editingTaskId,
         loading,
         error,
+        clearTaskError,
         title,
         setTitle,
+        setTitleDraft,
         description,
         setDescription,
+        setDescriptionDraft,
         checklistItems,
         setChecklistItems,
         category,
@@ -3560,8 +4325,6 @@ export function useTaskforce({ config = {}, initialTaskId, onTaskCountChange, on
         setComplexity,
         status,
         setStatus,
-        approach,
-        setApproach,
         assignee,
         setAssignee,
         scheduledDate,
@@ -3579,19 +4342,19 @@ export function useTaskforce({ config = {}, initialTaskId, onTaskCountChange, on
         setAttachments,
         attachmentsDirty,
         setAttachmentsDirty,
+        descriptionImageUploadPending,
+        descriptionImageDraftId,
+        registerDescriptionImageUpload,
         descriptionFocused,
         setDescriptionFocused,
         showMarkdownHelp,
         setShowMarkdownHelp,
-        showChecklist,
-        setShowChecklist,
-        showComments,
-        setShowComments,
         isCapturingScreenshot,
         setIsCapturingScreenshot,
         // Form Actions
         handleSubmit,
         resetForm,
+        discardDescriptionImageDraft,
         handleAddComment,
         handleSetWorkstreamForCurrentTask,
         handleOpenTaskById,
@@ -3618,13 +4381,13 @@ export function useTaskforce({ config = {}, initialTaskId, onTaskCountChange, on
         cancelScheduleWarning,
         tasksScrollRef,
         setTasksScrollPos, // Export if needed
-        // Export
-        exportEnvironment,
-        setExportEnvironment,
-        exportWorkflowsPath,
-        setExportWorkflowsPath,
-        exportResult,
-        exportingResource,
+        taskforceAgentId,
+        setTaskforceAgentId,
+        taskforceAgentConversationId,
+        setTaskforceAgentConversationId,
+        taskforceAgentConversationByAgentId,
+        setTaskforceAgentConversationByAgentId,
+        uiStateReady,
         // Categories & Types & Taxonomies mgmt
         handleUpdateCategory,
         handleRemoveCategory,
@@ -3652,17 +4415,9 @@ export function useTaskforce({ config = {}, initialTaskId, onTaskCountChange, on
         currentTask,
         currentTaskWorkstream,
         currentTaskInitiative,
-        availableWorkflows,
         initiativeTemplates,
-        availableEnvironments,
-        fetchWorkflows,
         fetchInitiativeTemplates,
         createInitiativeFromTemplate,
-        fetchWorkflowTemplate,
-        fetchWorkflowOverrideNames,
-        saveWorkflowTemplateDraft,
-        resetWorkflowTemplateDraft,
-        onExportWorkflows: handleExportWorkflows,
         settingsModel
     };
 }