@taskforcehq/taskforce 0.3.324 → 0.3.327

package/dist/hooks/workspace/useTaskforceWorkspaceBootstrap.js

@@ -7,7 +7,7 @@ function getBootstrapTimestamp() {
     return typeof performance !== 'undefined' ? performance.now() : Date.now();
 }
 export function useTaskforceWorkspaceBootstrap(args) {
-    const { shouldDeferProtectedApiCalls, shouldBlockProtectedApiCalls, getWorkspaceRequestState, isWorkspaceRequestStale, isWorkspaceEpochStale, isAbortError, isBootstrapTimeoutError, fetchWithTimeout, handleUnauthorized, applyBootstrapConfig, loadPersistedUiState, fetchBuildInfo, markBootstrapPhase, markBootstrapStalled, fetchWorkflows, fetchInitiativeTemplates, loadAvailableEnvironments, setReferenceDataLoaded, setCustomCategories, setCustomTypes, setPriorities, setTaxonomies, setTaxonomyDisplayLabels, setConfigLoaded, hasLoadedUiStateRef, currentWorkspaceIdRef, referenceDataRequestRef, referenceDataAbortRef, bootstrapConfigAbortRef, workspaceListAbortRef, assigneeOptionsAbortRef, workspaceListHydratedRef, setAvailableWorkspaces, runtimeMode, applyResolvedWorkspaceId, workspaceSwitchingEnabled, authSessionResolved, isAuthenticated, authUserId, authUserAvatarUrl, setHydratedWorkspaceRole, setAssigneeOptions, setAssigneeOptionsLoaded, commitCurrentWorkspaceId, currentWorkspaceId, workspaceSelectionScope, abortWorkspaceScopedRequests, setWorkspaceBootstrapPending, checkAuthSession, lastConfigRefreshKeyRef, lastAssigneeOptionsLoadKeyRef, lastWorkspaceSyncStateLoadKeyRef, lastTaskSurfaceLoadKeyRef, lastSettingsSurfaceLoadKeyRef, isOpen, activeTab, showArchive, taskScope, settingsSection, workspaceBootstrapPending, fetchTasks, fetchArchive, fetchPlanningEntities, refreshTaskCollections, loadWorkspaceSyncState, archiveBootstrapTimerRef, hasBootstrappedDataRef } = args;
+    const { shouldDeferProtectedApiCalls, shouldBlockProtectedApiCalls, getWorkspaceRequestState, isWorkspaceRequestStale, isWorkspaceEpochStale, isAbortError, isBootstrapTimeoutError, fetchWithTimeout, handleUnauthorized, applyBootstrapConfig, loadPersistedUiState, fetchBuildInfo, markBootstrapPhase, markBootstrapStalled, fetchInitiativeTemplates, setReferenceDataLoaded, setCustomCategories, setCustomTypes, setPriorities, setTaxonomies, setTaxonomyDisplayLabels, setConfigLoaded, hasLoadedUiStateRef, currentWorkspaceIdRef, referenceDataRequestRef, referenceDataAbortRef, bootstrapConfigAbortRef, workspaceListAbortRef, assigneeOptionsAbortRef, workspaceListHydratedRef, setAvailableWorkspaces, runtimeMode, applyResolvedWorkspaceId, workspaceSwitchingEnabled, authSessionResolved, isAuthenticated, authUserId, authUserAvatarUrl, setHydratedWorkspaceRole, setAssigneeOptions, setAssigneeOptionsLoaded, commitCurrentWorkspaceId, currentWorkspaceId, workspaceSelectionScope, abortWorkspaceScopedRequests, setWorkspaceBootstrapPending, checkAuthSession, lastConfigRefreshKeyRef, lastAssigneeOptionsLoadKeyRef, lastWorkspaceSyncStateLoadKeyRef, lastTaskSurfaceLoadKeyRef, lastSettingsSurfaceLoadKeyRef, isOpen, activeTab, showArchive, taskScope, settingsSection, workspaceBootstrapPending, fetchTasks, fetchPlanningEntities, refreshTaskCollections, loadWorkspaceSyncState, switchLocalCoordinatorWorkspace, hasBootstrappedDataRef } = args;
     const fetchReferenceData = useCallback(async (options) => {
         const ignoreAuthGuard = options?.ignoreAuthGuard === true;
         const force = options?.force === true;
@@ -102,9 +102,7 @@ export function useTaskforceWorkspaceBootstrap(args) {
                         taxonomies: normalized.taxonomies.length
                     });
                 })(),
-                fetchWorkflows(),
-                fetchInitiativeTemplates(),
-                loadAvailableEnvironments()
+                fetchInitiativeTemplates()
             ]);
             if (isWorkspaceRequestStale(requestState))
                 return;
@@ -125,7 +123,7 @@ export function useTaskforceWorkspaceBootstrap(args) {
             if (referenceDataAbortRef.current === abortController)
                 referenceDataAbortRef.current = null;
         }
-    }, [authSessionResolved, fetchInitiativeTemplates, fetchWorkflows, getWorkspaceRequestState, isAuthenticated, isWorkspaceRequestStale, loadAvailableEnvironments, referenceDataAbortRef, referenceDataRequestRef, runtimeMode, setCustomCategories, setCustomTypes, setPriorities, setReferenceDataLoaded, setTaxonomies, setTaxonomyDisplayLabels, shouldBlockProtectedApiCalls, shouldDeferProtectedApiCalls]);
+    }, [authSessionResolved, fetchInitiativeTemplates, getWorkspaceRequestState, isAuthenticated, isWorkspaceRequestStale, referenceDataAbortRef, referenceDataRequestRef, runtimeMode, setCustomCategories, setCustomTypes, setPriorities, setReferenceDataLoaded, setTaxonomies, setTaxonomyDisplayLabels, shouldBlockProtectedApiCalls, shouldDeferProtectedApiCalls]);
     const fetchBootstrapConfig = useCallback(async (options) => {
         const ignoreAuthGuard = options?.ignoreAuthGuard === true;
         if (!ignoreAuthGuard && (shouldDeferProtectedApiCalls || shouldBlockProtectedApiCalls))
@@ -199,16 +197,6 @@ export function useTaskforceWorkspaceBootstrap(args) {
         await fetchBootstrapConfig(options);
         await fetchReferenceData(options);
     }, [fetchBootstrapConfig, fetchReferenceData]);
-    const scheduleDeferredArchiveBootstrap = useCallback(() => {
-        if (typeof window === 'undefined')
-            return;
-        if (archiveBootstrapTimerRef.current !== null)
-            window.clearTimeout(archiveBootstrapTimerRef.current);
-        archiveBootstrapTimerRef.current = window.setTimeout(() => {
-            archiveBootstrapTimerRef.current = null;
-            void fetchArchive(true).then(() => logBootstrapDebug('bootstrap_archive_loaded_deferred', {}));
-        }, 1500);
-    }, [archiveBootstrapTimerRef, fetchArchive]);
     const fetchWorkspaces = useCallback(async () => {
         if (!workspaceSwitchingEnabled) {
             setAvailableWorkspaces([]);
@@ -335,6 +323,10 @@ export function useTaskforceWorkspaceBootstrap(args) {
                         avatarRevision: Number.isFinite(Number(entry?.avatarRevision)) ? Math.max(0, Math.floor(Number(entry.avatarRevision))) : null,
                         avatarUpdatedAt: typeof entry?.avatarUpdatedAt === 'string' && entry.avatarUpdatedAt.trim().length > 0 ? entry.avatarUpdatedAt.trim() : null,
                         username: typeof entry?.username === 'string' && entry.username.trim().length > 0 ? entry.username.trim() : null,
+                        surfaceType: typeof entry?.surfaceType === 'string' && entry.surfaceType.trim().length > 0 ? entry.surfaceType.trim() : null,
+                        providerMetadata: entry?.providerMetadata && typeof entry.providerMetadata === 'object' && !Array.isArray(entry.providerMetadata)
+                            ? entry.providerMetadata
+                            : null,
                         archivedAt: typeof entry?.archivedAt === 'string' && entry.archivedAt.trim().length > 0 ? entry.archivedAt.trim() : null,
                         createdAt: typeof entry?.createdAt === 'string' && entry.createdAt.trim().length > 0 ? entry.createdAt.trim() : null,
                         updatedAt: typeof entry?.updatedAt === 'string' && entry.updatedAt.trim().length > 0 ? entry.updatedAt.trim() : null
@@ -422,7 +414,10 @@ export function useTaskforceWorkspaceBootstrap(args) {
                 toWorkspaceId: normalizedWorkspaceId,
                 hydrate: options?.hydrate !== false
             });
-            const res = await fetch('/api/taskforce/session/workspace', {
+            const switchSessionUrl = runtimeMode === 'local'
+                ? '/api/taskforce/session/workspace?taskforceCloud=1'
+                : '/api/taskforce/session/workspace';
+            const res = await fetch(switchSessionUrl, {
                 method: 'POST',
                 headers: { 'Content-Type': 'application/json' },
                 credentials: 'include',
@@ -431,6 +426,29 @@ export function useTaskforceWorkspaceBootstrap(args) {
             const data = await res.json().catch(() => ({}));
             if (!res.ok || data?.success === false)
                 return { success: false, error: data?.error || `Failed to switch workspace (${res.status})`, code: data?.code };
+            try {
+                if (previousWorkspaceId !== 'default') {
+                    await switchLocalCoordinatorWorkspace(normalizedWorkspaceId);
+                }
+            }
+            catch (coordinatorError) {
+                if (previousWorkspaceId && previousWorkspaceId !== 'default') {
+                    await fetch(switchSessionUrl, {
+                        method: 'POST',
+                        headers: { 'Content-Type': 'application/json' },
+                        credentials: 'include',
+                        body: JSON.stringify({ workspaceId: previousWorkspaceId })
+                    }).catch(() => null);
+                    await checkAuthSession({ force: true }).catch(() => false);
+                }
+                return {
+                    success: false,
+                    error: coordinatorError instanceof Error
+                        ? coordinatorError.message
+                        : 'The local sync coordinator rejected the workspace switch.',
+                    code: String(coordinatorError?.code || 'SYNC_COORDINATOR_WORKSPACE_SWITCH_FAILED')
+                };
+            }
             commitCurrentWorkspaceId(normalizedWorkspaceId, { clearExplicitSelection: false });
             abortWorkspaceScopedRequests();
             setWorkspaceBootstrapPending(true);
@@ -443,8 +461,10 @@ export function useTaskforceWorkspaceBootstrap(args) {
                 lastConfigRefreshKeyRef.current = `${runtimeMode}:${normalizedWorkspaceId}:${workspaceSelectionScope}`;
                 lastAssigneeOptionsLoadKeyRef.current = `${runtimeMode}:${authenticated ? 'auth' : 'guest'}:${normalizedWorkspaceId}`;
                 lastWorkspaceSyncStateLoadKeyRef.current = normalizedWorkspaceId;
-                if (isOpen && activeTab === 'tasks')
-                    lastTaskSurfaceLoadKeyRef.current = `${normalizedWorkspaceId}:${activeTab}:${showArchive ? 'archive' : 'active'}:${taskScope}`;
+                const requiresHistoricalTaskHydration = showArchive || taskScope === 'archived' || taskScope === 'deleted';
+                if (isOpen && activeTab === 'tasks' && !requiresHistoricalTaskHydration) {
+                    lastTaskSurfaceLoadKeyRef.current = `${normalizedWorkspaceId}:${activeTab}:active:${taskScope}`;
+                }
                 if (isOpen && activeTab === 'settings')
                     lastSettingsSurfaceLoadKeyRef.current = `${normalizedWorkspaceId}:${activeTab}:${settingsSection}`;
                 await Promise.all([
@@ -476,7 +496,7 @@ export function useTaskforceWorkspaceBootstrap(args) {
         finally {
             setWorkspaceBootstrapPending(false);
         }
-    }, [abortWorkspaceScopedRequests, activeTab, checkAuthSession, commitCurrentWorkspaceId, currentWorkspaceIdRef, fetchConfig, fetchPlanningEntities, fetchWorkspaces, isOpen, lastAssigneeOptionsLoadKeyRef, lastConfigRefreshKeyRef, lastSettingsSurfaceLoadKeyRef, lastTaskSurfaceLoadKeyRef, lastWorkspaceSyncStateLoadKeyRef, loadWorkspaceSyncState, markBootstrapPhase, refreshTaskCollections, runtimeMode, settingsSection, setWorkspaceBootstrapPending, showArchive, taskScope, workspaceSelectionScope, workspaceSwitchingEnabled]);
+    }, [abortWorkspaceScopedRequests, activeTab, checkAuthSession, commitCurrentWorkspaceId, currentWorkspaceIdRef, fetchConfig, fetchPlanningEntities, fetchWorkspaces, isOpen, lastAssigneeOptionsLoadKeyRef, lastConfigRefreshKeyRef, lastSettingsSurfaceLoadKeyRef, lastTaskSurfaceLoadKeyRef, lastWorkspaceSyncStateLoadKeyRef, loadWorkspaceSyncState, markBootstrapPhase, refreshTaskCollections, runtimeMode, settingsSection, setWorkspaceBootstrapPending, showArchive, switchLocalCoordinatorWorkspace, taskScope, workspaceSelectionScope, workspaceSwitchingEnabled]);
     const resolveWorkspaceAfterAuth = useCallback(async (options) => {
         markBootstrapPhase('workspace');
         setWorkspaceBootstrapPending(true);
@@ -572,7 +592,6 @@ export function useTaskforceWorkspaceBootstrap(args) {
         const reason = options?.reason || 'initial-load';
         const ignoreAuthGuard = options?.ignoreAuthGuard === true;
         const tasksSilent = options?.tasksSilent !== false;
-        const includeDeferredArchive = options?.includeDeferredArchive !== false;
         const startedAt = getBootstrapTimestamp();
         markBootstrapPhase('auth');
         const authenticated = await checkAuthSession({ force: true });
@@ -651,9 +670,6 @@ export function useTaskforceWorkspaceBootstrap(args) {
                 });
             });
             void fetchPlanningEntities({ ignoreAuthGuard });
-            if (includeDeferredArchive) {
-                scheduleDeferredArchiveBootstrap();
-            }
             logBootstrapDebug('cloud_bootstrap_completed', {
                 reason,
                 durationMs: Math.max(0, Math.round(getBootstrapTimestamp() - startedAt)),
@@ -676,7 +692,6 @@ export function useTaskforceWorkspaceBootstrap(args) {
         fetchTasks,
         markBootstrapPhase,
         resolveWorkspaceAfterAuth,
-        scheduleDeferredArchiveBootstrap,
         setWorkspaceBootstrapPending,
         workspaceSwitchingEnabled
     ]);
@@ -688,24 +703,20 @@ export function useTaskforceWorkspaceBootstrap(args) {
                 if (runtimeMode === 'cloud' && authSessionResolved && isAuthenticated) {
                     const result = await runCloudBootstrap({
                         reason: 'initial-load',
-                        tasksSilent: false,
-                        includeDeferredArchive: true
+                        tasksSilent: false
                     });
                     if (!result.success || result.workspaceSetupRequired) {
                         return;
                     }
                 }
                 else {
+                    await fetchBootstrapConfig();
                     await Promise.all([
-                        fetchBootstrapConfig(),
                         fetchTasks(false),
                         fetchReferenceData()
                     ]);
                     void fetchPlanningEntities();
                 }
-                if (runtimeMode !== 'cloud') {
-                    scheduleDeferredArchiveBootstrap();
-                }
                 logBootstrapDebug('bootstrap_initial_load_completed', {
                     durationMs: Math.max(0, Math.round(getBootstrapTimestamp() - startedAt)),
                     runtimeMode,
@@ -713,7 +724,7 @@ export function useTaskforceWorkspaceBootstrap(args) {
                 });
             })();
         }
-    }, [authSessionResolved, currentWorkspaceIdRef, fetchBootstrapConfig, fetchPlanningEntities, fetchReferenceData, fetchTasks, hasBootstrappedDataRef, isAuthenticated, runCloudBootstrap, runtimeMode, scheduleDeferredArchiveBootstrap, shouldBlockProtectedApiCalls, shouldDeferProtectedApiCalls]);
+    }, [authSessionResolved, currentWorkspaceIdRef, fetchBootstrapConfig, fetchPlanningEntities, fetchReferenceData, fetchTasks, hasBootstrappedDataRef, isAuthenticated, runCloudBootstrap, runtimeMode, shouldBlockProtectedApiCalls, shouldDeferProtectedApiCalls]);
     useEffect(() => {
         if (shouldDeferProtectedApiCalls || shouldBlockProtectedApiCalls || workspaceBootstrapPending || workspaceSelectionScope === 'bootstrap' || !hasBootstrappedDataRef.current)
             return;

package/dist/hooks/workspace/workspaceLocalState.d.ts

@@ -1,11 +1,25 @@
 import type { TaskAssignee } from '../../types';
 import type { TaskSortKey } from '../../utils/taxonomySorting.js';
+export declare const APP_UI_STATE_VERSION = 1;
+export type WorkspaceModuleId = 'tasks' | 'planning' | 'docs' | 'annotate' | 'workflowManager' | 'taskforceAgents' | 'aiProfiles';
+export type PersistedGroupBy = 'category' | 'type' | 'priority' | 'assignee' | 'status' | 'complexity' | 'schedule' | 'docs';
+export interface FilterTaxonomySignature {
+    categories: string[];
+    types: string[];
+    priorities: string[];
+    taxonomies: Record<string, string[]>;
+}
 export interface PersistedUiState {
-    groupBy?: 'category' | 'type' | 'priority' | 'approach' | 'assignee' | 'status' | 'complexity' | 'schedule' | 'docs';
-    activeWorkspaceModule?: 'tasks' | 'docs' | 'annotate' | 'workflows' | 'agents';
+    version?: number;
+    groupBy?: PersistedGroupBy;
+    activeWorkspaceModule?: WorkspaceModuleId;
     emptyColumnMode?: 'show' | 'collapse' | 'hide';
+    taskScope?: 'open' | 'archived' | 'deleted';
+    openTaskId?: string | null;
+    compressedCards?: boolean;
     zenMode?: boolean;
     searchQuery?: string;
+    collapsedCategories?: Record<string, boolean>;
     filterCategories?: string[];
     filterPriorities?: (string | number)[];
     filterTypes?: string[];
@@ -13,14 +27,14 @@ export interface PersistedUiState {
     filterAssignees?: TaskAssignee[];
     filterAssigneesAllSelected?: boolean;
     filterTaxonomies?: Record<string, (string | number)[]>;
+    filterTaxonomySignature?: FilterTaxonomySignature;
     sortBy?: TaskSortKey;
     sortOrder?: 'asc' | 'desc';
     hasInitedFilters?: boolean;
-    showChecklist?: boolean;
-    showWorkstreamSection?: boolean;
-    showTaskRelationships?: boolean;
     lastCategory?: string;
-    exportEnvironment?: string;
+    taskforceAgentId?: string;
+    taskforceAgentConversationId?: string;
+    taskforceAgentConversationByAgentId?: Record<string, string>;
 }
 type RemoteUiStatePersistResult = {
     skipped: boolean;
@@ -28,6 +42,25 @@ type RemoteUiStatePersistResult = {
     response?: Response;
     payload?: any;
 };
+export declare function normalizePersistedUiState(input: unknown): PersistedUiState | null;
+export declare function buildFilterTaxonomySignature(input: {
+    categories: Array<{
+        value?: unknown;
+    }>;
+    types: Array<{
+        value?: unknown;
+    }>;
+    priorities: Array<{
+        value?: unknown;
+    }>;
+    taxonomies?: Array<{
+        id?: unknown;
+        options?: Array<{
+            value?: unknown;
+        }>;
+    }>;
+}): FilterTaxonomySignature | null;
+export declare function areFilterTaxonomySignaturesEqual(left: FilterTaxonomySignature | null | undefined, right: FilterTaxonomySignature | null | undefined): boolean;
 export declare function generateClientUuid(): string;
 export declare function logBootstrapDebug(event: string, details?: Record<string, unknown>): void;
 export declare function resetRemoteUiStatePersistCache(): void;
@@ -36,10 +69,13 @@ export declare function persistRemoteUiState(input: {
     workspaceId?: string | null;
     patch: object;
     headers?: Record<string, string>;
+    useCloudProxy?: boolean;
     throwOnError?: boolean;
     failureRetryMs?: number;
     skipIfUnchanged?: boolean;
     respectFailureCooldown?: boolean;
+    keepalive?: boolean;
+    dedupeScope?: string;
 }): Promise<RemoteUiStatePersistResult>;
 export declare function readPersistedWorkspaceId(scopeRaw?: string): string;
 export declare function writePersistedWorkspaceId(workspaceId: string, scopeRaw?: string): void;

package/dist/hooks/workspace/workspaceLocalState.js

@@ -1,9 +1,215 @@
 import { isReservedWorkspaceId, normalizeWorkspaceStorageScope, normalizeWorkspaceStorageScopeLegacy } from '../../utils/workspaceIdentity';
+export const APP_UI_STATE_VERSION = 1;
 const WORKSPACE_CONTEXT_KEY_PREFIX = 'taskforce.workspaceContext.v2';
 const APP_UI_STATE_STORAGE_KEY_PREFIX = 'taskforce.uiState.app.v1';
 const BOOTSTRAP_DEBUG_LOG_KEY = 'taskforce.bootstrapDebug.v1';
 const REMOTE_UI_STATE_FAILURE_RETRY_MS = 5000;
 const remoteUiStatePersistCache = new Map();
+function normalizeSignatureValues(values) {
+    return Array.from(new Set(values
+        .map((value) => String(value ?? '').trim())
+        .filter((value) => value.length > 0))).sort();
+}
+function isRecord(value) {
+    return Boolean(value && typeof value === 'object' && !Array.isArray(value));
+}
+function normalizeStringArray(value) {
+    if (!Array.isArray(value))
+        return undefined;
+    return Array.from(new Set(value
+        .filter((entry) => typeof entry === 'string')
+        .map((entry) => entry.trim())
+        .filter(Boolean)));
+}
+function normalizePrimitiveArray(value) {
+    if (!Array.isArray(value))
+        return undefined;
+    return Array.from(new Set(value.filter((entry) => ((typeof entry === 'string' && entry.trim().length > 0)
+        || typeof entry === 'number'))));
+}
+function normalizeFilterTaxonomies(value) {
+    if (!isRecord(value))
+        return undefined;
+    const normalized = {};
+    Object.entries(value).forEach(([key, values]) => {
+        const taxonomyId = String(key || '').trim();
+        const taxonomyValues = normalizePrimitiveArray(values);
+        if (!taxonomyId || !taxonomyValues)
+            return;
+        normalized[taxonomyId] = taxonomyValues;
+    });
+    return normalized;
+}
+function normalizeBooleanRecord(value) {
+    if (!isRecord(value))
+        return undefined;
+    const normalized = {};
+    Object.entries(value).forEach(([key, entryValue]) => {
+        const normalizedKey = String(key || '').trim();
+        if (!normalizedKey || typeof entryValue !== 'boolean')
+            return;
+        normalized[normalizedKey] = entryValue;
+    });
+    return normalized;
+}
+function normalizeStringRecord(value) {
+    if (!isRecord(value))
+        return undefined;
+    const normalized = {};
+    Object.entries(value).forEach(([key, entryValue]) => {
+        const normalizedKey = String(key || '').trim();
+        if (!normalizedKey || typeof entryValue !== 'string')
+            return;
+        const normalizedValue = entryValue.trim();
+        if (!normalizedValue)
+            return;
+        normalized[normalizedKey] = normalizedValue;
+    });
+    return normalized;
+}
+function normalizeFilterTaxonomySignature(value) {
+    if (!isRecord(value))
+        return undefined;
+    const categories = normalizeStringArray(value.categories);
+    const types = normalizeStringArray(value.types);
+    const priorities = normalizeStringArray(value.priorities);
+    if (!categories || !types || !priorities)
+        return undefined;
+    const taxonomies = {};
+    if (isRecord(value.taxonomies)) {
+        Object.entries(value.taxonomies).forEach(([key, values]) => {
+            const taxonomyId = String(key || '').trim();
+            const taxonomyValues = normalizeStringArray(values);
+            if (!taxonomyId || !taxonomyValues)
+                return;
+            taxonomies[taxonomyId] = taxonomyValues;
+        });
+    }
+    return { categories, types, priorities, taxonomies };
+}
+export function normalizePersistedUiState(input) {
+    if (!isRecord(input))
+        return null;
+    const next = { version: APP_UI_STATE_VERSION };
+    const groupByValues = ['category', 'type', 'priority', 'assignee', 'status', 'complexity', 'schedule', 'docs'];
+    if (input.groupBy === 'approach') {
+        next.groupBy = 'status';
+    }
+    if (typeof input.groupBy === 'string' && groupByValues.includes(input.groupBy)) {
+        next.groupBy = input.groupBy;
+    }
+    const moduleValue = input.activeWorkspaceModule === 'agents'
+        ? 'aiProfiles'
+        : input.activeWorkspaceModule === 'workflows'
+            ? 'tasks'
+            : input.activeWorkspaceModule;
+    const moduleValues = ['tasks', 'planning', 'docs', 'annotate', 'workflowManager', 'taskforceAgents', 'aiProfiles'];
+    if (typeof moduleValue === 'string' && moduleValues.includes(moduleValue)) {
+        next.activeWorkspaceModule = moduleValue;
+    }
+    if (input.emptyColumnMode === 'show' || input.emptyColumnMode === 'collapse' || input.emptyColumnMode === 'hide') {
+        next.emptyColumnMode = input.emptyColumnMode;
+    }
+    if (input.taskScope === 'open' || input.taskScope === 'archived' || input.taskScope === 'deleted') {
+        next.taskScope = input.taskScope;
+    }
+    if (typeof input.openTaskId === 'string') {
+        next.openTaskId = input.openTaskId.trim() || null;
+    }
+    else if (input.openTaskId === null) {
+        next.openTaskId = null;
+    }
+    if (typeof input.compressedCards === 'boolean')
+        next.compressedCards = input.compressedCards;
+    if (typeof input.zenMode === 'boolean')
+        next.zenMode = input.zenMode;
+    if (typeof input.searchQuery === 'string')
+        next.searchQuery = input.searchQuery;
+    const collapsedCategories = normalizeBooleanRecord(input.collapsedCategories);
+    if (collapsedCategories)
+        next.collapsedCategories = collapsedCategories;
+    const filterCategories = normalizeStringArray(input.filterCategories);
+    if (filterCategories)
+        next.filterCategories = filterCategories;
+    const filterPriorities = normalizePrimitiveArray(input.filterPriorities);
+    if (filterPriorities)
+        next.filterPriorities = filterPriorities;
+    const filterTypes = normalizeStringArray(input.filterTypes);
+    if (filterTypes)
+        next.filterTypes = filterTypes;
+    const filterStatus = normalizePrimitiveArray(input.filterStatus);
+    if (filterStatus)
+        next.filterStatus = filterStatus;
+    const filterAssignees = normalizeStringArray(input.filterAssignees);
+    if (filterAssignees)
+        next.filterAssignees = filterAssignees;
+    if (typeof input.filterAssigneesAllSelected === 'boolean') {
+        next.filterAssigneesAllSelected = input.filterAssigneesAllSelected;
+    }
+    const filterTaxonomies = normalizeFilterTaxonomies(input.filterTaxonomies);
+    if (filterTaxonomies)
+        next.filterTaxonomies = filterTaxonomies;
+    const filterTaxonomySignature = normalizeFilterTaxonomySignature(input.filterTaxonomySignature);
+    if (filterTaxonomySignature)
+        next.filterTaxonomySignature = filterTaxonomySignature;
+    if (input.sortBy === 'created' || input.sortBy === 'priority' || input.sortBy === 'updated' || input.sortBy === 'complexity') {
+        next.sortBy = input.sortBy;
+    }
+    if (input.sortOrder === 'asc' || input.sortOrder === 'desc')
+        next.sortOrder = input.sortOrder;
+    if (typeof input.hasInitedFilters === 'boolean')
+        next.hasInitedFilters = input.hasInitedFilters;
+    if (typeof input.lastCategory === 'string')
+        next.lastCategory = input.lastCategory;
+    if (typeof input.taskforceAgentId === 'string') {
+        const taskforceAgentId = input.taskforceAgentId.trim();
+        if (taskforceAgentId)
+            next.taskforceAgentId = taskforceAgentId;
+    }
+    if (typeof input.taskforceAgentConversationId === 'string') {
+        const taskforceAgentConversationId = input.taskforceAgentConversationId.trim();
+        if (taskforceAgentConversationId)
+            next.taskforceAgentConversationId = taskforceAgentConversationId;
+    }
+    const taskforceAgentConversationByAgentId = normalizeStringRecord(input.taskforceAgentConversationByAgentId);
+    if (taskforceAgentConversationByAgentId && Object.keys(taskforceAgentConversationByAgentId).length > 0) {
+        next.taskforceAgentConversationByAgentId = taskforceAgentConversationByAgentId;
+    }
+    return next;
+}
+export function buildFilterTaxonomySignature(input) {
+    const categories = normalizeSignatureValues(input.categories.map((category) => category.value));
+    const types = normalizeSignatureValues(input.types.map((type) => type.value));
+    const priorities = normalizeSignatureValues(input.priorities.map((priority) => priority.value));
+    if (categories.length === 0 || types.length === 0 || priorities.length === 0)
+        return null;
+    const taxonomies = {};
+    (input.taxonomies || []).forEach((taxonomy) => {
+        const id = String(taxonomy.id ?? '').trim();
+        if (!id)
+            return;
+        taxonomies[id] = normalizeSignatureValues((taxonomy.options || []).map((option) => option.value));
+    });
+    return { categories, types, priorities, taxonomies };
+}
+function haveSameStringValues(left, right) {
+    return left.length === right.length && left.every((value, index) => value === right[index]);
+}
+export function areFilterTaxonomySignaturesEqual(left, right) {
+    if (!left || !right)
+        return false;
+    if (!haveSameStringValues(left.categories || [], right.categories || []))
+        return false;
+    if (!haveSameStringValues(left.types || [], right.types || []))
+        return false;
+    if (!haveSameStringValues(left.priorities || [], right.priorities || []))
+        return false;
+    const leftTaxonomyKeys = Object.keys(left.taxonomies || {}).sort();
+    const rightTaxonomyKeys = Object.keys(right.taxonomies || {}).sort();
+    if (!haveSameStringValues(leftTaxonomyKeys, rightTaxonomyKeys))
+        return false;
+    return leftTaxonomyKeys.every((key) => (haveSameStringValues(left.taxonomies[key] || [], right.taxonomies[key] || [])));
+}
 export function generateClientUuid() {
     if (typeof crypto !== 'undefined' && typeof crypto.randomUUID === 'function') {
         return crypto.randomUUID();
@@ -27,10 +233,11 @@ export function logBootstrapDebug(event, details) {
     const payload = details && typeof details === 'object' ? details : {};
     console.info('[Taskforce Bootstrap]', event, payload);
 }
-function buildRemoteUiStatePersistKey(stateKeyRaw, workspaceIdRaw) {
+function buildRemoteUiStatePersistKey(stateKeyRaw, workspaceIdRaw, dedupeScopeRaw, useCloudProxy = false) {
     const stateKey = String(stateKeyRaw || 'default').trim() || 'default';
     const workspaceId = String(workspaceIdRaw || 'default').trim() || 'default';
-    return `${workspaceId}::${stateKey}`;
+    const dedupeScope = String(dedupeScopeRaw || 'default').trim() || 'default';
+    return `${useCloudProxy ? 'cloud' : 'same-origin'}::${workspaceId}::${stateKey}::${dedupeScope}`;
 }
 export function resetRemoteUiStatePersistCache() {
     remoteUiStatePersistCache.clear();
@@ -40,7 +247,7 @@ export async function persistRemoteUiState(input) {
     const workspaceId = String(input.workspaceId || '').trim();
     const patch = input.patch && typeof input.patch === 'object' ? input.patch : {};
     const serializedPatch = JSON.stringify(patch);
-    const persistKey = buildRemoteUiStatePersistKey(stateKey, workspaceId || 'default');
+    const persistKey = buildRemoteUiStatePersistKey(stateKey, workspaceId || 'default', input.dedupeScope, input.useCloudProxy);
     const now = Date.now();
     const cached = remoteUiStatePersistCache.get(persistKey);
     if (cached && cached.serializedPatch === serializedPatch) {
@@ -63,10 +270,11 @@ export async function persistRemoteUiState(input) {
         }
     }
     try {
-        const response = await fetch('/api/taskforce/ui-state', {
+        const response = await fetch(`/api/taskforce/ui-state${input.useCloudProxy ? '?taskforceCloud=1' : ''}`, {
             method: 'POST',
             headers: { 'Content-Type': 'application/json', ...(input.headers || {}) },
             credentials: 'include',
+            ...(input.keepalive ? { keepalive: true } : {}),
             body: JSON.stringify({
                 stateKey,
                 ...(workspaceId ? { workspaceId } : {}),
@@ -183,7 +391,7 @@ export function readPersistedAppUiState(scopeRaw) {
         if (!raw)
             return null;
         const parsed = JSON.parse(raw);
-        return parsed && typeof parsed === 'object' ? parsed : null;
+        return normalizePersistedUiState(parsed);
     }
     catch {
         return null;

package/dist/hooks/workstreams/workstreamHttpMutation.d.ts

@@ -0,0 +1,23 @@
+import { type LocalOperationIdentityStore, type LocalWorkstreamCreateAttemptStore } from '../../sync/v3/localOperationIdentityStore.js';
+import type { WorkstreamItem } from '../../types.js';
+export declare function selectCreatedWorkstreamAfterRefresh(current: WorkstreamItem[], created: WorkstreamItem): WorkstreamItem | null;
+export declare function isConclusiveWorkstreamHttpResponse(response: Response): Promise<boolean>;
+export declare function createCloudWorkstreamHttpMutationClient(input?: {
+    operationIdentities?: LocalOperationIdentityStore;
+    createAttempts?: LocalWorkstreamCreateAttemptStore;
+}): {
+    prepareCreate(workspaceId: string, candidate: Record<string, unknown>): Promise<{
+        fingerprint: string;
+        operationId: string;
+        body: Record<string, unknown>;
+    }>;
+    confirmCreate(fingerprint: string, operationId: string): Promise<void>;
+    abandonCreate(fingerprint: string, operationId: string): Promise<void>;
+    prepareMutation(workspaceId: string, url: string, body: Record<string, unknown>, observedState?: Record<string, unknown> | null): Promise<{
+        fingerprint: string;
+        operationId: string;
+    }>;
+    confirmMutation(fingerprint: string, operationId: string): Promise<void>;
+    abandonMutation(fingerprint: string, operationId: string): Promise<void>;
+};
+export declare function fetchWorkstreamHttpMutation(url: string, init: RequestInit, operationId: string): Promise<Response>;