@taskforcehq/taskforce 0.3.301 → 0.3.303

package/dist/hooks/useTaskData.test.js

@@ -44,6 +44,25 @@ function makeAbortableRequestRejectingWithReason(payload) {
         }
     };
 }
+function makeControlledAbortableRequest(payload) {
+    let rejectRequest = null;
+    let resolveRequest = null;
+    const promise = new Promise((resolve, reject) => {
+        rejectRequest = reject;
+        resolveRequest = () => resolve(makeAbortableFetchResponse(payload));
+    });
+    return {
+        promise,
+        resolve() {
+            resolveRequest?.();
+        },
+        attach(signal) {
+            signal?.addEventListener('abort', () => {
+                rejectRequest?.(new DOMException('Aborted', 'AbortError'));
+            }, { once: true });
+        }
+    };
+}
 describe('useTaskData', () => {
     beforeEach(() => {
         vi.stubGlobal('fetch', vi.fn());
@@ -177,4 +196,51 @@ describe('useTaskData', () => {
         expect(consoleErrorSpy).not.toHaveBeenCalledWith('[Taskforce] Failed to fetch archive:', 'superseded');
         expect(consoleErrorSpy).not.toHaveBeenCalled();
     });
+    it('keeps loading active until the replacement tasks request finishes', async () => {
+        const firstRequest = makeControlledAbortableRequest({ tasks: [] });
+        const secondRequest = makeControlledAbortableRequest({ tasks: [] });
+        const fetchMock = vi.mocked(fetch);
+        const setLoadingTasks = vi.fn();
+        let requestCount = 0;
+        fetchMock.mockImplementation((_input, init) => {
+            const signal = init?.signal;
+            requestCount += 1;
+            if (requestCount === 1) {
+                firstRequest.attach(signal);
+                return firstRequest.promise;
+            }
+            secondRequest.attach(signal);
+            return secondRequest.promise;
+        });
+        const { result } = renderHook(() => useTaskData({
+            tasks: [],
+            archivedTasks: [],
+            setTasks: vi.fn(),
+            setArchivedTasks: vi.fn(),
+            setLoadingTasks,
+            getCurrentWorkspaceId: () => 'workspace-1',
+            workspaceResetKey: 'workspace-1',
+            shouldDeferProtectedApiCalls: false,
+            shouldBlockProtectedApiCalls: false,
+            handleUnauthorized: vi.fn(),
+            authRequiredForApi: false
+        }));
+        let firstPromise;
+        let secondPromise;
+        await act(async () => {
+            firstPromise = result.current.fetchTasks(false);
+            secondPromise = result.current.fetchTasks(false);
+            await Promise.resolve();
+        });
+        expect(setLoadingTasks).toHaveBeenNthCalledWith(1, true);
+        expect(setLoadingTasks).toHaveBeenNthCalledWith(2, true);
+        expect(setLoadingTasks).toHaveBeenCalledTimes(2);
+        await act(async () => {
+            secondRequest.resolve();
+            await secondPromise;
+            await firstPromise;
+        });
+        expect(setLoadingTasks).toHaveBeenLastCalledWith(false);
+        expect(setLoadingTasks).toHaveBeenCalledTimes(3);
+    });
 });

package/dist/hooks/useTaskforce.d.ts

@@ -117,8 +117,10 @@ export declare function useTaskforce({ config, initialTaskId, onTaskCountChange,
     authRequiredForApi: boolean;
     authBlocked: boolean;
     isAuthenticated: boolean;
+    authUserId: string;
     authUserEmail: string;
     authUserDisplayName: string;
+    authUserAvatarUrl: string;
     authWorkspaceId: string;
     userGlobalSyncStatus: "error" | "idle" | "syncing" | "disconnected";
     workspaceLastPullAt: string | null;
@@ -247,9 +249,14 @@ export declare function useTaskforce({ config, initialTaskId, onTaskCountChange,
         emailSent?: boolean;
         emailError?: string;
         workspaceSetupRequired?: boolean;
+        planSelectionRequired?: boolean;
+        checkoutPending?: boolean;
+        commercialState?: string | null;
     }>;
     updateCurrentUserProfile: (input: {
         displayName: string;
+        avatarDraftId?: string | null;
+        clearAvatar?: boolean;
     }) => Promise<{
         success: boolean;
         error?: string;
@@ -258,6 +265,7 @@ export declare function useTaskforce({ config, initialTaskId, onTaskCountChange,
             userId: string;
             email: string;
             displayName: string | null;
+            avatarUrl: string | null;
         };
     }>;
     requestEmailVerification: (email: string) => Promise<{

package/dist/hooks/useTaskforce.js

@@ -45,7 +45,7 @@ import { cloneDefaultWorkflowDefinitions } from '../shared/workflowDefaults.js';
 import { resolveClientDeploymentConfig } from '../config/clientDeployment';
 import { resolveTaskforceMcpBaseUrlFromBaseUrl } from '../config/cloudEnvironment';
 import { createDefaultAssigneeOptions, createWorkspaceAssigneeOptions, mergeAssigneeOptions } from '../utils/assignees';
-import { persistLocalMutationActorUserId } from '../utils/taskforceApiClient';
+import { persistLocalMutationActorUserId, readLocalMutationActorUserId } from '../utils/taskforceApiClient';
 import { useSyncOrchestrator } from './useSyncOrchestrator';
 import { useRealtimeSync } from './useRealtimeSync';
 import { useUiNotice } from './ui/useUiNotice';
@@ -129,8 +129,6 @@ export function useTaskforce({ config = {}, initialTaskId, onTaskCountChange, on
                 const workspaceMode = workspaceModeRaw === 'single-local' || workspaceModeRaw === 'multi-cloud'
                     ? workspaceModeRaw
                     : (runtimeModeHint === 'cloud' ? 'multi-cloud' : 'single-local');
-                const authSourceRaw = String(cfg.authSource || '').trim().toLowerCase();
-                const authSource = authSourceRaw === 'local' ? 'local' : 'cloud';
                 setRuntimeConfigOverride({
                     cloudEnvironment: typeof cfg.cloudEnvironment === 'string'
                         ? String(cfg.cloudEnvironment).trim().toLowerCase()
@@ -142,7 +140,7 @@ export function useTaskforce({ config = {}, initialTaskId, onTaskCountChange, on
                     cloudAuthBaseUrl: normalizeBaseUrl(cfg.cloudAuthBaseUrl),
                     wsBaseUrl: normalizeBaseUrl(cfg.wsBaseUrl),
                     cloudAuthViaLocalProxy: Boolean(cfg.cloudAuthViaLocalProxy),
-                    authSource,
+                    authSource: 'cloud',
                     workspaceMode,
                     workspaceSwitchingEnabled: typeof cfg.workspaceSwitchingEnabled === 'boolean'
                         ? Boolean(cfg.workspaceSwitchingEnabled)
@@ -182,8 +180,10 @@ export function useTaskforce({ config = {}, initialTaskId, onTaskCountChange, on
         || '';
     const explicitConfiguredCloudAuthBaseUrl = propCloudAuthBaseUrl || envCloudAuthBaseUrl || envBaseUrl;
     const runtimeResolvedCloudAuthBaseUrl = runtimeConfigOverride.cloudAuthBaseUrl || runtimeConfigOverride.baseUrl;
-    const normalizedCloudAuthBaseUrl = (explicitConfiguredCloudAuthBaseUrl
-        || runtimeResolvedCloudAuthBaseUrl
+    const preferredCloudAuthBaseUrl = isLoopbackHost
+        ? (runtimeResolvedCloudAuthBaseUrl || explicitConfiguredCloudAuthBaseUrl)
+        : (explicitConfiguredCloudAuthBaseUrl || runtimeResolvedCloudAuthBaseUrl);
+    const normalizedCloudAuthBaseUrl = (preferredCloudAuthBaseUrl
         || normalizedApiBaseUrl
         || defaultCloudAuthBaseUrl).trim().replace(/\/+$/, '');
     const inferredCloudMcpBaseUrl = normalizeBaseUrl(resolveTaskforceMcpBaseUrlFromBaseUrl(runtimeConfigOverride.cloudMcpBaseUrl
@@ -208,6 +208,10 @@ export function useTaskforce({ config = {}, initialTaskId, onTaskCountChange, on
     const shouldGateProtectedApiCalls = shouldProbeCloudAuth && !authOnlyCloudMode;
     const cloudAuthConfigured = Boolean(normalizedCloudAuthBaseUrl || normalizedApiBaseUrl || isCloudHost);
     const initialRuntimeMode = isCloudHost ? 'cloud' : 'local';
+    const optimisticLocalAuthUserId = initialRuntimeMode === 'local' && isLoopbackHost && cloudAuthConfigured
+        ? readLocalMutationActorUserId()
+        : '';
+    const hasOptimisticLocalAuth = optimisticLocalAuthUserId.length > 0;
     const resolveApiUrl = useCallback((path) => {
         if (!path)
             return path;
@@ -225,6 +229,8 @@ export function useTaskforce({ config = {}, initialTaskId, onTaskCountChange, on
         if (!path.startsWith('/'))
             return path;
         const isCloudScopedPath = path.startsWith('/api/taskforce/auth/')
+            || path.startsWith('/api/taskforce/account/')
+            || path.startsWith('/api/taskforce/billing/')
             || path.startsWith('/api/taskforce/sync/')
             || path.startsWith('/api/taskforce/settings/mcp/');
         if (!isCloudHost && isCloudScopedPath && (!runtimeConfigReady || runtimeConfigOverride.cloudAuthViaLocalProxy)) {
@@ -310,11 +316,12 @@ export function useTaskforce({ config = {}, initialTaskId, onTaskCountChange, on
         : runtimeContractFallback.workspaceSwitchingEnabled;
     const [authRequiredForApi, setAuthRequiredForApi] = useState(false);
     const [authBlocked, setAuthBlocked] = useState(false);
-    const [isAuthenticated, setIsAuthenticated] = useState(false);
-    const [authUserId, setAuthUserId] = useState('anonymous');
+    const [isAuthenticated, setIsAuthenticated] = useState(hasOptimisticLocalAuth);
+    const [authUserId, setAuthUserId] = useState(hasOptimisticLocalAuth ? optimisticLocalAuthUserId : 'anonymous');
     const [authWorkspaceId, setAuthWorkspaceId] = useState('');
     const [authUserEmail, setAuthUserEmail] = useState('');
     const [authUserDisplayName, setAuthUserDisplayName] = useState('');
+    const [authUserAvatarUrl, setAuthUserAvatarUrl] = useState('');
     const [hasBetaAccess, setHasBetaAccess] = useState(true);
     const [hydratedWorkspaceRole, setHydratedWorkspaceRole] = useState(null);
     const [currentWorkspaceId, setCurrentWorkspaceId] = useState(() => {
@@ -333,13 +340,13 @@ export function useTaskforce({ config = {}, initialTaskId, onTaskCountChange, on
     const [availableWorkspaces, setAvailableWorkspaces] = useState([]);
     const [assigneeOptions, setAssigneeOptions] = useState(() => createDefaultAssigneeOptions());
     const [workspaceBootstrapPending, setWorkspaceBootstrapPending] = useState(false);
-    const [authSessionResolved, setAuthSessionResolved] = useState(false);
+    const [authSessionResolved, setAuthSessionResolved] = useState(hasOptimisticLocalAuth);
     const [bootstrapPhase, setBootstrapPhase] = useState('idle');
     const [bootstrapError, setBootstrapError] = useState(null);
     const [bootstrapStartedAt, setBootstrapStartedAt] = useState(null);
     const authSessionRequestRef = useRef(null);
     const authSessionLastCheckedAtRef = useRef(0);
-    const authSessionLastResultRef = useRef(false);
+    const authSessionLastResultRef = useRef(hasOptimisticLocalAuth);
     const currentWorkspaceIdRef = useRef(currentWorkspaceId);
     const explicitWorkspaceSelectionRef = useRef(null);
     const workspaceTransitionEpochRef = useRef(0);
@@ -622,6 +629,7 @@ export function useTaskforce({ config = {}, initialTaskId, onTaskCountChange, on
         setIsAuthenticated(false);
         setAuthUserEmail('');
         setAuthUserDisplayName('');
+        setAuthUserAvatarUrl('');
         setError(AUTH_REQUIRED_ERROR);
     }, [AUTH_REQUIRED_ERROR, runtimeMode]);
     // === SECTION: Task Data ===
@@ -822,6 +830,7 @@ export function useTaskforce({ config = {}, initialTaskId, onTaskCountChange, on
             persistLocalMutationActorUserId(null);
             setAuthUserEmail('');
             setAuthUserDisplayName('');
+            setAuthUserAvatarUrl('');
             setUserGlobalSyncStatus('disconnected');
             setUserGlobalSyncError(null);
             setHasBetaAccess(true);
@@ -881,6 +890,9 @@ export function useTaskforce({ config = {}, initialTaskId, onTaskCountChange, on
                 const userDisplayName = typeof data.displayName === 'string'
                     ? data.displayName.trim()
                     : '';
+                const userAvatarUrl = typeof data.avatarUrl === 'string'
+                    ? data.avatarUrl.trim()
+                    : '';
                 const isLocalRuntime = runtimeMode === 'local';
                 const keepLocalWorkspaceContext = runtimeMode === 'local' || authOnlyCloudMode;
                 setAuthRequiredForApi(authOnlyCloudMode ? false : (isLocalRuntime ? false : required));
@@ -892,6 +904,7 @@ export function useTaskforce({ config = {}, initialTaskId, onTaskCountChange, on
                 }
                 setAuthUserEmail(authenticated ? userEmail : '');
                 setAuthUserDisplayName(authenticated ? userDisplayName : '');
+                setAuthUserAvatarUrl(authenticated ? userAvatarUrl : '');
                 if (authenticated) {
                     setError((prev) => prev === AUTH_REQUIRED_ERROR ? '' : prev);
                 }
@@ -1769,7 +1782,7 @@ export function useTaskforce({ config = {}, initialTaskId, onTaskCountChange, on
                 if (currentMemberRole === 'owner' || currentMemberRole === 'admin' || currentMemberRole === 'member' || currentMemberRole === 'read-only') {
                     setHydratedWorkspaceRole(currentMemberRole);
                 }
-                else if (!workspaceSwitchingEnabled) {
+                else if (!workspaceSwitchingEnabled && users.length === 0) {
                     setHydratedWorkspaceRole(null);
                 }
                 const workspaceMemberCandidates = users
@@ -1793,7 +1806,7 @@ export function useTaskforce({ config = {}, initialTaskId, onTaskCountChange, on
                     candidate
                 ])).values()).filter((candidate) => String(candidate.userId || '').trim().length > 0);
             }
-            else if (!workspaceSwitchingEnabled) {
+            else if (!workspaceSwitchingEnabled && !fallbackCandidates.length) {
                 setHydratedWorkspaceRole(null);
             }
             const mergedOptions = mergeAssigneeOptions([
@@ -1988,7 +2001,7 @@ export function useTaskforce({ config = {}, initialTaskId, onTaskCountChange, on
     const retryBootstrapChecks = useCallback(async () => {
         setBootstrapError(null);
         markBootstrapPhase('auth');
-        const authenticated = await checkAuthSession();
+        const authenticated = await checkAuthSession({ force: true });
         if (workspaceSwitchingEnabled && authenticated) {
             const workspaceResolution = await resolveWorkspaceAfterAuth();
             if (!workspaceResolution.success || workspaceResolution.workspaceSetupRequired) {
@@ -2055,7 +2068,7 @@ export function useTaskforce({ config = {}, initialTaskId, onTaskCountChange, on
             if (!res.ok || data?.success === false) {
                 return { success: false, error: data?.error || `Failed to delete workspace (${res.status})`, code: data?.code };
             }
-            await checkAuthSession();
+            await checkAuthSession({ force: true });
             await Promise.all([fetchConfig(), fetchWorkspaces()]);
             const nextWorkspaceId = typeof data?.nextWorkspaceId === 'string' ? data.nextWorkspaceId.trim() : '';
             if (nextWorkspaceId) {
@@ -2157,7 +2170,7 @@ export function useTaskforce({ config = {}, initialTaskId, onTaskCountChange, on
                 return { success: false, error: data?.error || 'Sign in failed.', code: data?.code };
             }
             setError('');
-            await checkAuthSession();
+            await checkAuthSession({ force: true });
             const workspaceResolution = await resolveWorkspaceAfterAuth();
             if (!workspaceResolution.success) {
                 return {
@@ -2218,6 +2231,9 @@ export function useTaskforce({ config = {}, initialTaskId, onTaskCountChange, on
             return {
                 success: true,
                 workspaceSetupRequired: Boolean(data?.workspaceSetupRequired),
+                planSelectionRequired: data?.planSelectionRequired === true,
+                checkoutPending: data?.checkoutPending === true,
+                commercialState: typeof data?.commercialState === 'string' ? data.commercialState : null,
                 verificationRequired: Boolean(data?.verificationRequired),
                 verificationToken: typeof data?.verificationToken === 'string' ? data.verificationToken : undefined,
                 emailSent: data?.emailSent !== false,
@@ -2233,6 +2249,8 @@ export function useTaskforce({ config = {}, initialTaskId, onTaskCountChange, on
             return { success: false, error: 'Cloud auth endpoint is not configured.' };
         }
         const trimmedDisplayName = String(input.displayName || '').trim();
+        const trimmedAvatarDraftId = typeof input.avatarDraftId === 'string' ? input.avatarDraftId.trim() : '';
+        const shouldClearAvatar = input.clearAvatar === true;
         if (!trimmedDisplayName) {
             return { success: false, error: 'Display name is required.' };
         }
@@ -2241,7 +2259,11 @@ export function useTaskforce({ config = {}, initialTaskId, onTaskCountChange, on
                 method: 'POST',
                 headers: { 'Content-Type': 'application/json' },
                 credentials: 'include',
-                body: JSON.stringify({ displayName: trimmedDisplayName })
+                body: JSON.stringify({
+                    displayName: trimmedDisplayName,
+                    ...(trimmedAvatarDraftId ? { avatarDraftId: trimmedAvatarDraftId } : {}),
+                    ...(shouldClearAvatar ? { clearAvatar: true } : {})
+                })
             });
             const data = await res.json().catch(() => ({}));
             if (!res.ok || !data?.success) {
@@ -2250,9 +2272,11 @@ export function useTaskforce({ config = {}, initialTaskId, onTaskCountChange, on
             const profile = {
                 userId: typeof data?.profile?.userId === 'string' ? data.profile.userId : authUserId,
                 email: typeof data?.profile?.email === 'string' ? data.profile.email : authUserEmail,
-                displayName: typeof data?.profile?.displayName === 'string' ? data.profile.displayName : null
+                displayName: typeof data?.profile?.displayName === 'string' ? data.profile.displayName : null,
+                avatarUrl: typeof data?.profile?.avatarUrl === 'string' ? data.profile.avatarUrl : null
             };
             setAuthUserDisplayName(profile.displayName || '');
+            setAuthUserAvatarUrl(profile.avatarUrl || '');
             return { success: true, profile };
         }
         catch {
@@ -2424,7 +2448,7 @@ export function useTaskforce({ config = {}, initialTaskId, onTaskCountChange, on
                 return { success: false, error: data?.error || 'Invite acceptance failed.', code: data?.code };
             }
             setError('');
-            await checkAuthSession();
+            await checkAuthSession({ force: true });
             const preferredWorkspaceId = typeof data?.workspaceId === 'string' ? data.workspaceId : null;
             const workspaceResolution = await resolveWorkspaceAfterAuth({ preferredWorkspaceId });
             if (!workspaceResolution.success) {
@@ -2505,13 +2529,20 @@ export function useTaskforce({ config = {}, initialTaskId, onTaskCountChange, on
             // no-op
         }
         finally {
+            authSessionRequestRef.current = null;
+            authSessionLastResultRef.current = false;
+            authSessionLastCheckedAtRef.current = Date.now();
             setIsAuthenticated(false);
+            setAuthSessionResolved(true);
             setAuthUserId('anonymous');
+            setAuthWorkspaceId('');
             persistLocalMutationActorUserId(null);
             setAuthUserEmail('');
             setAuthUserDisplayName('');
+            setAuthUserAvatarUrl('');
             setUserGlobalSyncStatus('disconnected');
             setUserGlobalSyncError(null);
+            setHasBetaAccess(true);
             setAuthBlocked(runtimeMode === 'cloud' && authRequiredForApi);
             setCurrentWorkspaceId((prev) => {
                 const existing = String(prev || '').trim();
@@ -2527,11 +2558,31 @@ export function useTaskforce({ config = {}, initialTaskId, onTaskCountChange, on
             });
             setAvailableWorkspaces([]);
             workspaceListHydratedRef.current = false;
+            setHydratedWorkspaceRole(null);
+            if (runtimeMode === 'local') {
+                await Promise.allSettled([
+                    fetchConfig({ ignoreAuthGuard: true }),
+                    fetchTasks(true, { ignoreAuthGuard: true }),
+                    fetchPlanningEntities({ ignoreAuthGuard: true }),
+                    fetchReferenceData({ ignoreAuthGuard: true, force: true })
+                ]);
+                return;
+            }
             setTasks([]);
             setInitiatives([]);
             setWorkstreams([]);
         }
-    }, [authRequiredForApi, resolveCloudAuthUrl, cloudAuthConfigured, workspaceSelectionScope, runtimeMode]);
+    }, [
+        authRequiredForApi,
+        resolveCloudAuthUrl,
+        cloudAuthConfigured,
+        workspaceSelectionScope,
+        runtimeMode,
+        fetchConfig,
+        fetchPlanningEntities,
+        fetchReferenceData,
+        fetchTasks
+    ]);
     const createInitiativeFromTemplate = useCallback(async (payload) => {
         try {
             const res = await fetch('/api/taskforce/initiative-templates/create', {
@@ -3456,8 +3507,10 @@ export function useTaskforce({ config = {}, initialTaskId, onTaskCountChange, on
         authRequiredForApi,
         authBlocked,
         isAuthenticated,
+        authUserId,
         authUserEmail,
         authUserDisplayName,
+        authUserAvatarUrl,
         authWorkspaceId,
         userGlobalSyncStatus,
         workspaceLastPullAt,

package/dist/hooks/useTaskforce.sync-behavior.test.js

@@ -87,6 +87,7 @@ const archivedTaskRecord = (id, title) => ({
 describe('useTaskforce sync behavior', () => {
     beforeEach(() => {
         localStorage.clear();
+        sessionStorage.clear();
     });
     afterEach(() => {
         vi.useRealTimers();
@@ -97,7 +98,7 @@ describe('useTaskforce sync behavior', () => {
     it('merges a server-returned task into the active collection immediately', async () => {
         vi.stubGlobal('fetch', vi.fn((url, init) => {
             if (url.includes('/api/taskforce/auth/runtime-config')) {
-                return jsonResponse({ config: { runtimeMode: 'local', workspaceMode: 'single-local', authSource: 'local' } });
+                return jsonResponse({ config: { runtimeMode: 'local', workspaceMode: 'single-local', authSource: 'cloud' } });
             }
             if (url.includes('/api/taskforce/auth/session')) {
                 return jsonResponse({
@@ -188,7 +189,7 @@ describe('useTaskforce sync behavior', () => {
     it('keeps the dawn theme when settings re-fetch configuration', async () => {
         const fetchMock = vi.fn((url) => {
             if (url.includes('/api/taskforce/auth/runtime-config')) {
-                return jsonResponse({ config: { runtimeMode: 'local', workspaceMode: 'single-local', authSource: 'local' } });
+                return jsonResponse({ config: { runtimeMode: 'local', workspaceMode: 'single-local', authSource: 'cloud' } });
             }
             if (url.includes('/api/taskforce/auth/session')) {
                 return jsonResponse({
@@ -261,7 +262,7 @@ describe('useTaskforce sync behavior', () => {
     it('merges a server-returned archived task immediately instead of dropping it between collections', async () => {
         vi.stubGlobal('fetch', vi.fn((url, init) => {
             if (url.includes('/api/taskforce/auth/runtime-config')) {
-                return jsonResponse({ config: { runtimeMode: 'local', workspaceMode: 'single-local', authSource: 'local' } });
+                return jsonResponse({ config: { runtimeMode: 'local', workspaceMode: 'single-local', authSource: 'cloud' } });
             }
             if (url.includes('/api/taskforce/ui-state?key=app')) {
                 return jsonResponse({ success: true, state: {} });
@@ -339,7 +340,7 @@ describe('useTaskforce sync behavior', () => {
     it('merges a server-returned completed task immediately when toggling done', async () => {
         vi.stubGlobal('fetch', vi.fn((url, init) => {
             if (url.includes('/api/taskforce/auth/runtime-config')) {
-                return jsonResponse({ config: { runtimeMode: 'local', workspaceMode: 'single-local', authSource: 'local' } });
+                return jsonResponse({ config: { runtimeMode: 'local', workspaceMode: 'single-local', authSource: 'cloud' } });
             }
             if (url.includes('/api/taskforce/ui-state?key=app')) {
                 return jsonResponse({ success: true, state: {} });
@@ -416,7 +417,7 @@ describe('useTaskforce sync behavior', () => {
         vi.stubGlobal('confirm', vi.fn(() => true));
         vi.stubGlobal('fetch', vi.fn((url, init) => {
             if (url.includes('/api/taskforce/auth/runtime-config')) {
-                return jsonResponse({ config: { runtimeMode: 'local', workspaceMode: 'single-local', authSource: 'local' } });
+                return jsonResponse({ config: { runtimeMode: 'local', workspaceMode: 'single-local', authSource: 'cloud' } });
             }
             if (url.includes('/api/taskforce/ui-state?key=app')) {
                 return jsonResponse({ success: true, state: {} });
@@ -503,7 +504,7 @@ describe('useTaskforce sync behavior', () => {
                     config: {
                         runtimeMode: 'local',
                         workspaceMode: 'single-local',
-                        authSource: 'local',
+                        authSource: 'cloud',
                         baseUrl: 'http://localhost:5174',
                         apiBaseUrl: 'http://localhost:5174',
                         cloudAuthBaseUrl: 'http://localhost:5174'
@@ -918,6 +919,184 @@ describe('useTaskforce sync behavior', () => {
             expect(result.current.assigneeOptions.some((option) => option.value === 'ai-profile-codex' && option.label === 'Codex')).toBe(true);
         });
     });
+    it('keeps the local hydrated workspace role when workspace-members temporarily fails', async () => {
+        let workspaceMembersCalls = 0;
+        vi.stubGlobal('fetch', vi.fn((url) => {
+            if (url.includes('/api/taskforce/auth/runtime-config')) {
+                return jsonResponse({
+                    config: {
+                        runtimeMode: 'local',
+                        workspaceMode: 'single-local',
+                        authSource: 'cloud',
+                        workspaceSwitchingEnabled: false
+                    }
+                });
+            }
+            if (url.includes('/api/taskforce/auth/session')) {
+                return jsonResponse({
+                    authenticated: true,
+                    authRequiredForApi: true,
+                    betaAccess: true,
+                    userId: 'user-1',
+                    email: 'user@example.com',
+                    workspaceId: 'workspace-cloud-1'
+                });
+            }
+            if (url.includes('/api/taskforce/ui-state?key=app'))
+                return jsonResponse({ success: true, state: {} });
+            if (url.includes('/api/taskforce/ui-state?key=workspace-sync')) {
+                return jsonResponse({
+                    success: true,
+                    state: { version: 2, enabled: false, phase: 'idle', pullCursor: null }
+                });
+            }
+            if (url.includes('/api/taskforce/config')) {
+                return jsonResponse({
+                    projectName: 'Local Project',
+                    workspaceId: 'workspace-cloud-1',
+                    runtimeMode: 'local',
+                    authRequiredForApi: true,
+                    userId: 'user-1',
+                    setupState: {
+                        globalSetupState: 'complete',
+                        workspaceSetupState: 'complete',
+                        workspaceId: 'workspace-cloud-1'
+                    }
+                });
+            }
+            if (url.includes('/api/taskforce/global-settings'))
+                return jsonResponse({});
+            if (url.includes('/api/taskforce/categories'))
+                return jsonResponse({ categories: [{ value: 'general', label: 'General' }] });
+            if (url.includes('/api/taskforce/types'))
+                return jsonResponse({ types: [] });
+            if (url.includes('/api/taskforce/priorities'))
+                return jsonResponse({ priorities: [] });
+            if (url.includes('/api/taskforce/approaches'))
+                return jsonResponse({ approaches: [] });
+            if (url.includes('/api/taskforce/specialists'))
+                return jsonResponse({ specialists: [] });
+            if (url.includes('/api/taskforce/tasks'))
+                return jsonResponse({ tasks: [activeTask] });
+            if (url.includes('/api/taskforce/archive'))
+                return jsonResponse({ archived: [] });
+            if (url.includes('/api/taskforce/workspace/assignee-options')) {
+                return jsonResponse({
+                    assignees: [
+                        { value: 'member-1', label: 'Member One', icon: 'User', color: '#22c55e', kind: 'member', userId: 'member-1', email: 'member1@example.com' }
+                    ]
+                });
+            }
+            if (url.includes('/api/taskforce/auth/workspace-members')) {
+                workspaceMembersCalls += 1;
+                if (workspaceMembersCalls === 1) {
+                    return jsonResponse({
+                        users: [
+                            {
+                                userId: 'user-1',
+                                email: 'user@example.com',
+                                displayName: 'Signed In Owner',
+                                role: 'owner',
+                                status: 'active',
+                                disabled: false
+                            }
+                        ]
+                    });
+                }
+                return Promise.reject(new Error('temporary workspace-members failure'));
+            }
+            if (url.includes('/api/taskforce/data-version'))
+                return jsonResponse({ dataVersion: 1 });
+            return jsonResponse({});
+        }));
+        const { result } = renderHook(() => useTaskforce({ config: { cloudAuthBaseUrl: 'https://cloud.example.com' } }), { wrapper });
+        await waitFor(() => {
+            expect(result.current.currentWorkspaceRole).toBe('owner');
+        });
+        await act(async () => {
+            await result.current.fetchAssigneeOptions();
+        });
+        expect(result.current.currentWorkspaceRole).toBe('owner');
+    });
+    it('seeds local auth state from the persisted loopback actor while localhost session bootstrap is in flight', async () => {
+        sessionStorage.setItem('taskforce.localMutationActorUserId.v1', 'user-1');
+        const fetchMock = vi.fn((url) => {
+            if (url.includes('/api/taskforce/auth/runtime-config')) {
+                return jsonResponse({
+                    config: {
+                        runtimeMode: 'local',
+                        workspaceMode: 'single-local',
+                        authSource: 'cloud',
+                        workspaceSwitchingEnabled: false,
+                        cloudAuthBaseUrl: 'https://app.taskforcehq.ai',
+                        cloudAuthViaLocalProxy: true
+                    }
+                });
+            }
+            if (url.includes('/api/taskforce/auth/session')) {
+                return jsonResponse({
+                    authenticated: true,
+                    authRequiredForApi: true,
+                    betaAccess: true,
+                    userId: 'user-1',
+                    email: 'user@example.com',
+                    workspaceId: 'workspace-cloud-1'
+                });
+            }
+            if (url.includes('/api/taskforce/ui-state?key=app'))
+                return jsonResponse({ success: true, state: {} });
+            if (url.includes('/api/taskforce/ui-state?key=workspace-sync')) {
+                return jsonResponse({
+                    success: true,
+                    state: { version: 2, enabled: false, phase: 'idle', pullCursor: null }
+                });
+            }
+            if (url.includes('/api/taskforce/config')) {
+                return jsonResponse({
+                    projectName: 'Local Project',
+                    workspaceId: 'workspace-cloud-1',
+                    runtimeMode: 'local',
+                    setupState: {
+                        globalSetupState: 'complete',
+                        workspaceSetupState: 'complete',
+                        workspaceId: 'workspace-cloud-1'
+                    }
+                });
+            }
+            if (url.includes('/api/taskforce/global-settings'))
+                return jsonResponse({});
+            if (url.includes('/api/taskforce/categories'))
+                return jsonResponse({ categories: [{ value: 'general', label: 'General' }] });
+            if (url.includes('/api/taskforce/types'))
+                return jsonResponse({ types: [] });
+            if (url.includes('/api/taskforce/priorities'))
+                return jsonResponse({ priorities: [] });
+            if (url.includes('/api/taskforce/approaches'))
+                return jsonResponse({ approaches: [] });
+            if (url.includes('/api/taskforce/specialists'))
+                return jsonResponse({ specialists: [] });
+            if (url.includes('/api/taskforce/tasks'))
+                return jsonResponse({ tasks: [activeTask] });
+            if (url.includes('/api/taskforce/archive'))
+                return jsonResponse({ archived: [] });
+            if (url.includes('/api/taskforce/workspace/assignee-options'))
+                return jsonResponse({ assignees: [] });
+            if (url.includes('/api/taskforce/data-version'))
+                return jsonResponse({ dataVersion: 1 });
+            return jsonResponse({});
+        });
+        vi.stubGlobal('fetch', fetchMock);
+        const { result } = renderHook(() => useTaskforce({ config: { cloudAuthBaseUrl: 'https://app.taskforcehq.ai' } }), { wrapper });
+        expect(result.current.isAuthenticated).toBe(true);
+        expect(result.current.authSessionResolved).toBe(true);
+        await waitFor(() => {
+            expect(fetchMock.mock.calls.some(([url]) => String(url).includes('/api/taskforce/auth/session'))).toBe(true);
+        });
+        await waitFor(() => {
+            expect(result.current.isAuthenticated).toBe(true);
+            expect(result.current.authSessionResolved).toBe(true);
+        });
+    });
     it('enables cloud realtime refresh for authenticated sessions and refreshes open task comments from signals', async () => {
         vi.stubGlobal('WebSocket', MockWebSocket);
         let invalidationTaskFetchCount = 0;