@taskforcehq/taskforce 0.3.329 → 0.3.332

package/dist/core/types.d.ts

@@ -15,6 +15,7 @@
 import type { DatabaseProvider } from '../storage/databaseAdapter.js';
 export type { TaskforceTheme } from '../utils/theme.js';
 import type { TaskforceTheme } from '../utils/theme.js';
+import type { InternalUserFeatureKey } from '../shared/userFeatureGrants.js';
 export interface Comment {
     id: string;
     author: string;
@@ -344,6 +345,7 @@ export type SystemRole = 'system_admin' | 'user';
 export type PermissionMode = 'read-only' | 'read-write';
 export type AuthTokenPurpose = 'email_verification' | 'password_reset' | 'invite_accept';
 export type McpAccessTokenScope = 'tasks:read' | 'tasks:write' | 'workspace:read';
+export type McpCloudToolProfile = 'default' | 'extended';
 export type UserAuthProvider = 'password' | 'google' | 'github' | 'apple';
 export interface UserAuthIdentity {
     id: string;
@@ -417,6 +419,7 @@ export interface SystemUserRecord {
     systemRole: SystemRole;
     betaAccess: boolean;
     disabled: boolean;
+    internalFeatureGrants: InternalUserFeatureKey[];
     planId?: string | null;
     planName?: string | null;
     planVersionId?: string | null;
@@ -613,6 +616,7 @@ export interface McpAccessTokenRecord {
     userEmail?: string | null;
     name: string;
     scopes: McpAccessTokenScope[];
+    toolProfile: McpCloudToolProfile;
     tokenPrefix: string;
     status: McpAccessTokenStatus;
     lastUsedAt?: string | null;
@@ -640,6 +644,7 @@ export interface McpAccessTokenAuthResult {
     workspaceId: string;
     userId: string;
     scopes: McpAccessTokenScope[];
+    toolProfile?: McpCloudToolProfile;
     status: McpAccessTokenStatus;
 }
 export interface McpAccessTokenInspectionResult {
@@ -649,12 +654,14 @@ export interface McpAccessTokenInspectionResult {
     userId: string;
     name: string;
     scopes: McpAccessTokenScope[];
+    toolProfile: McpCloudToolProfile;
     status: McpAccessTokenStatus;
 }
 export interface McpOAuthClientRecord {
     id: string;
     provider: McpOAuthProvider;
     clientName: string;
+    applicationType: 'native' | 'web';
     productClientId?: string | null;
     redirectUris: string[];
     status: McpOAuthClientStatus;
@@ -670,6 +677,7 @@ export interface McpOAuthConnectorGrantRecord {
     workspaceId: string;
     userId: string;
     scopes: McpAccessTokenScope[];
+    toolProfile: McpCloudToolProfile;
     tokenPrefix: string;
     status: McpOAuthGrantStatus;
     lastUsedAt?: string | null;
@@ -692,6 +700,7 @@ export interface McpOAuthAccessTokenAuthResult {
     provider: McpOAuthProvider;
     productClientId?: string | null;
     scopes: McpAccessTokenScope[];
+    toolProfile?: McpCloudToolProfile;
     status: McpOAuthGrantStatus;
     aiProfileId?: string | null;
     aiProfileToken?: string | null;

package/dist/documentReviews/DocumentReviewCommentStore.d.ts

@@ -77,6 +77,8 @@ export declare class DocumentReviewCommentStore {
         threadStatusUpdatedAt?: string | null;
         resolvedAt?: string | null;
         resolvedByActorId?: string | null;
+    }, options?: {
+        allowAuthoritativeThreadReconciliation?: boolean;
     }): DocumentReviewCommentSyncRecord;
     softDelete(commentIdRaw: string, workspaceIdRaw: string, deletedAtRaw?: string, deletedByActorIdRaw?: string | null): boolean;
     replaceForSession(input: {

package/dist/documentReviews/DocumentReviewCommentStore.js

@@ -235,7 +235,7 @@ export class DocumentReviewCommentStore {
             : (input.threadStatus === undefined ? existing.threadStatus : input.threadStatus), input.threadStatusUpdatedAt === undefined ? existing.threadStatusUpdatedAt : normalizeNullable(input.threadStatusUpdatedAt), input.resolvedAt === undefined ? existing.resolvedAt : normalizeNullable(input.resolvedAt), input.resolvedByActorId === undefined ? existing.resolvedByActorId : normalizeNullable(input.resolvedByActorId), normalizeId(input.updatedAt) || new Date().toISOString(), input.deletedAt === undefined ? existing.deletedAt : normalizeNullable(input.deletedAt), this.tenantId, normalizeWorkspaceId(input.workspaceId), normalizeId(input.id));
         return this.get(input.id, input.workspaceId, { includeDeleted: true });
     }
-    upsertForSync(input) {
+    upsertForSync(input, options) {
         const existing = this.get(input.id, input.workspaceId, { includeDeleted: true });
         if (!existing) {
             return this.create(input);
@@ -248,7 +248,20 @@ export class DocumentReviewCommentStore {
             ? undefined
             : normalizeNullable(input.parentCommentId);
         if (incomingParentCommentId !== undefined && incomingParentCommentId !== existing.parentCommentId) {
-            throw new Error(`Document review comment ${existing.id} cannot move between threads.`);
+            if (options?.allowAuthoritativeThreadReconciliation !== true) {
+                throw new Error(`Document review comment ${existing.id} cannot move between threads.`);
+            }
+            const incomingParent = incomingParentCommentId
+                ? this.get(incomingParentCommentId, input.workspaceId, { includeDeleted: true })
+                : null;
+            if (existing.parentCommentId
+                || !incomingParent
+                || incomingParent.deletedAt
+                || incomingParent.sessionId !== existing.sessionId
+                || incomingParent.parentCommentId
+                || incomingParent.id === existing.id) {
+                throw new Error(`Document review comment ${existing.id} cannot reconcile to an invalid thread root.`);
+            }
         }
         const incomingThreadStatusUpdatedAt = input.threadStatusUpdatedAt === undefined
             ? undefined
@@ -283,13 +296,19 @@ export class DocumentReviewCommentStore {
               AND id = ?
         `).run(normalizeId(input.sessionId) || existing.sessionId, normalizeId(input.body), input.anchor ? JSON.stringify(input.anchor) : null, normalizeNullable(input.authorActorId), normalizeNullable(input.updatedByActorId), input.deletedByActorId === undefined ? existing.deletedByActorId : normalizeNullable(input.deletedByActorId), nextParentCommentId, nextParentCommentId
             ? null
-            : (shouldApplyThreadLifecycle ? input.threadStatus : existing.threadStatus), shouldApplyThreadLifecycle
-            ? incomingThreadStatusUpdatedAt
-            : existing.threadStatusUpdatedAt, shouldApplyThreadLifecycle
-            ? normalizeNullable(input.resolvedAt)
-            : existing.resolvedAt, shouldApplyThreadLifecycle
-            ? normalizeNullable(input.resolvedByActorId)
-            : existing.resolvedByActorId, normalizePositiveInteger(input.order) ?? existing.order, normalizeId(input.createdAt) || existing.createdAt, normalizeId(input.updatedAt) || existing.updatedAt, existing.deletedAt || (input.deletedAt === undefined
+            : (shouldApplyThreadLifecycle ? input.threadStatus : existing.threadStatus), nextParentCommentId
+            ? null
+            : shouldApplyThreadLifecycle
+                ? incomingThreadStatusUpdatedAt
+                : existing.threadStatusUpdatedAt, nextParentCommentId
+            ? null
+            : shouldApplyThreadLifecycle
+                ? normalizeNullable(input.resolvedAt)
+                : existing.resolvedAt, nextParentCommentId
+            ? null
+            : shouldApplyThreadLifecycle
+                ? normalizeNullable(input.resolvedByActorId)
+                : existing.resolvedByActorId, normalizePositiveInteger(input.order) ?? existing.order, normalizeId(input.createdAt) || existing.createdAt, normalizeId(input.updatedAt) || existing.updatedAt, existing.deletedAt || (input.deletedAt === undefined
             ? null
             : normalizeNullable(input.deletedAt)), this.tenantId, normalizeWorkspaceId(input.workspaceId), normalizeId(input.id));
         return this.get(input.id, input.workspaceId, { includeDeleted: true });

package/dist/documentReviews/commandService.d.ts

@@ -6,6 +6,7 @@ export interface ReviewDocumentCommandComment {
 export interface ReviewDocumentCommandInput {
     workspaceId: string;
     assetId: string;
+    documentVersion: number | null;
     documentLabel?: string | null;
     sessionId?: string | null;
     title?: string | null;
@@ -43,7 +44,7 @@ export declare class DocumentReviewCommandError extends Error {
 }
 export interface ReviewDocumentCommandResult {
     session: DocumentReviewSession;
-    sessionAction: 'reused' | 'created';
+    sessionAction: 'reused' | 'created' | 'created-for-current-version';
     postedCommentIds: string[];
 }
 export declare function createDocumentReviewCommandService(deps: DocumentReviewCommandServiceDependencies): {

package/dist/documentReviews/commandService.js

@@ -29,8 +29,9 @@ export function createDocumentReviewCommandService(deps) {
                     workspaceId: input.workspaceId,
                     assetId: input.assetId,
                 }).filter((candidate) => candidate.status === 'open');
-                if (openSessions.length === 1) {
-                    session = openSessions[0];
+                const currentVersionSessions = openSessions.filter((candidate) => candidate.documentVersion === input.documentVersion);
+                if (currentVersionSessions.length === 1) {
+                    session = currentVersionSessions[0];
                 }
                 else {
                     session = deps.createSession({
@@ -40,7 +41,9 @@ export function createDocumentReviewCommandService(deps) {
                         status: 'open',
                         actorId: input.actorId,
                     });
-                    sessionAction = 'created';
+                    sessionAction = currentVersionSessions.length === 0 && openSessions.length > 0
+                        ? 'created-for-current-version'
+                        : 'created';
                 }
             }
             const postedCommentIds = [];

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

@@ -28,6 +28,7 @@ export interface PersistedSyncWatermarks {
     taskRelationshipChangeKeys?: Map<string, string>;
     initiativeWatermarks: Map<string, string>;
     workstreamWatermarks: Map<string, string>;
+    planningIdentityWatermarks?: Map<string, string>;
     aiProfileWatermarks: Map<string, string>;
     aiProfileChangeKeys?: Map<string, string>;
     taskforceAgentWatermarks?: Map<string, string>;

package/dist/hooks/sync/orchestratorShared.js

@@ -180,6 +180,7 @@ export function buildPersistedSyncWatermarksSnapshot(data) {
         taskRelationshipChangeKeys: Array.from((data.taskRelationshipChangeKeys || new Map()).entries()),
         initiativeWatermarks: Array.from(data.initiativeWatermarks.entries()),
         workstreamWatermarks: Array.from(data.workstreamWatermarks.entries()),
+        planningIdentityWatermarks: Array.from((data.planningIdentityWatermarks || new Map()).entries()),
         aiProfileWatermarks: Array.from(data.aiProfileWatermarks.entries()),
         aiProfileChangeKeys: Array.from((data.aiProfileChangeKeys || new Map()).entries()),
         taskforceAgentWatermarks: Array.from((data.taskforceAgentWatermarks || new Map()).entries()),
@@ -214,6 +215,7 @@ export function parsePersistedSyncWatermarksSnapshot(snapshot, taxonomyStateFing
         taskRelationshipChangeKeys: new Map(Array.isArray(snapshot.taskRelationshipChangeKeys) ? snapshot.taskRelationshipChangeKeys : []),
         initiativeWatermarks: new Map(Array.isArray(snapshot.initiativeWatermarks) ? snapshot.initiativeWatermarks : []),
         workstreamWatermarks: new Map(Array.isArray(snapshot.workstreamWatermarks) ? snapshot.workstreamWatermarks : []),
+        planningIdentityWatermarks: new Map(Array.isArray(snapshot.planningIdentityWatermarks) ? snapshot.planningIdentityWatermarks : []),
         aiProfileWatermarks: new Map(Array.isArray(snapshot.aiProfileWatermarks) ? snapshot.aiProfileWatermarks : []),
         aiProfileChangeKeys: new Map(Array.isArray(snapshot.aiProfileChangeKeys) ? snapshot.aiProfileChangeKeys : []),
         taskforceAgentWatermarks: new Map(Array.isArray(snapshot.taskforceAgentWatermarks) ? snapshot.taskforceAgentWatermarks : []),

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

@@ -12,9 +12,12 @@ export declare function useLocalSyncCoordinatorSnapshot(input: {
     pollIntervalMs?: number;
     client?: LocalSyncCoordinatorBrowserClient;
 }): {
+    activeCommandType: LocalSyncCoordinatorCommandType | null;
+    activePriorityCommandType: LocalSyncCoordinatorCommandType | null;
     refresh: () => Promise<LocalSyncCoordinatorStatusResponse | null>;
     issueCommand: (type: Exclude<LocalSyncCoordinatorCommandType, "SwitchWorkspace" | "TransferOwnership">, args?: unknown) => Promise<LocalSyncCoordinatorCommandRecord>;
     signalWake: (source: "realtime" | "connectivity", eventIds?: string[]) => Promise<boolean>;
+    clearCredential: () => Promise<boolean>;
     switchWorkspace: (targetWorkspaceId: string) => Promise<LocalSyncCoordinatorStatusResponse["state"]>;
     transferOwnership: (targetMode: "server" | "browser-gateway") => Promise<LocalSyncCoordinatorStatusResponse["state"]>;
     phase: LocalSyncCoordinatorSnapshotPhase;

package/dist/hooks/sync/useLocalSyncCoordinatorSnapshot.js

@@ -15,8 +15,14 @@ export function useLocalSyncCoordinatorSnapshot(input) {
     const requestEpochRef = useRef(0);
     const commandLifecycleRef = useRef(null);
     const priorityCommandLifecycleRef = useRef(null);
+    const [activeCommandType, setActiveCommandType] = useState(null);
+    const [activePriorityCommandType, setActivePriorityCommandType] = useState(null);
     const snapshotRef = useRef(null);
     snapshotRef.current = state.snapshot;
+    useEffect(() => {
+        setActiveCommandType(null);
+        setActivePriorityCommandType(null);
+    }, [input.workspaceId]);
     const resumePendingCommand = useCallback((scope) => {
         const existing = commandLifecycleRef.current;
         if (existing?.workspaceId === input.workspaceId)
@@ -36,14 +42,17 @@ export function useLocalSyncCoordinatorSnapshot(input) {
         const lifecycle = {
             workspaceId: input.workspaceId,
             scope,
+            type: pending.type,
             promise,
         };
         commandLifecycleRef.current = lifecycle;
+        setActiveCommandType(pending.type);
         void promise
             .catch(() => { })
             .finally(() => {
             if (commandLifecycleRef.current === lifecycle) {
                 commandLifecycleRef.current = null;
+                setActiveCommandType(null);
             }
         });
         return promise;
@@ -68,14 +77,17 @@ export function useLocalSyncCoordinatorSnapshot(input) {
         const lifecycle = {
             workspaceId: input.workspaceId,
             scope,
+            type: pending.type,
             promise,
         };
         priorityCommandLifecycleRef.current = lifecycle;
+        setActivePriorityCommandType(pending.type);
         void promise
             .catch(() => { })
             .finally(() => {
             if (priorityCommandLifecycleRef.current === lifecycle) {
                 priorityCommandLifecycleRef.current = null;
+                setActivePriorityCommandType(null);
             }
         });
         return promise;
@@ -250,7 +262,7 @@ export function useLocalSyncCoordinatorSnapshot(input) {
         refresh,
     ]);
     const issueCommand = useCallback(async (type, args = null) => {
-        const snapshot = snapshotRef.current;
+        let snapshot = snapshotRef.current;
         if (!snapshot) {
             throw new LocalSyncCoordinatorBrowserClientError('The local sync coordinator is not attached.', 'SYNC_COORDINATOR_UNAVAILABLE', 409);
         }
@@ -258,21 +270,54 @@ export function useLocalSyncCoordinatorSnapshot(input) {
         if (priorityCommand) {
             const activePriority = priorityCommandLifecycleRef.current;
             if (activePriority?.workspaceId === input.workspaceId) {
-                return activePriority.promise;
+                if (activePriority.type === type)
+                    return activePriority.promise;
+                await activePriority.promise;
             }
             const resumedPriority = resumePendingPriorityCommand(scopeRef.current);
-            if (resumedPriority)
-                return resumedPriority;
+            if (resumedPriority) {
+                const resumedType = priorityCommandLifecycleRef.current?.type;
+                if (resumedType === type)
+                    return resumedPriority;
+                await resumedPriority;
+            }
         }
         const active = commandLifecycleRef.current;
-        if (!priorityCommand && active?.workspaceId === input.workspaceId) {
-            await active.promise;
+        if (active?.workspaceId === input.workspaceId) {
+            if (active.type === type)
+                return active.promise;
+            const activeIsToggle = active.type === 'EnableSync' || active.type === 'DisableSync';
+            if (!priorityCommand || activeIsToggle)
+                await active.promise;
         }
-        if (!priorityCommand) {
-            const resumed = resumePendingCommand(scopeRef.current);
-            if (resumed)
+        const resumed = resumePendingCommand(scopeRef.current);
+        if (resumed) {
+            const resumedType = commandLifecycleRef.current?.type;
+            if (resumedType === type)
+                return resumed;
+            const resumedIsToggle = resumedType === 'EnableSync' || resumedType === 'DisableSync';
+            if (!priorityCommand || resumedIsToggle)
                 await resumed;
         }
+        if (!priorityCommand) {
+            const activePriority = priorityCommandLifecycleRef.current;
+            if (activePriority?.workspaceId === input.workspaceId) {
+                if (activePriority.type === type)
+                    return activePriority.promise;
+                await activePriority.promise;
+            }
+            const resumedPriority = resumePendingPriorityCommand(scopeRef.current);
+            if (resumedPriority) {
+                const resumedType = priorityCommandLifecycleRef.current?.type;
+                if (resumedType === type)
+                    return resumedPriority;
+                await resumedPriority;
+            }
+        }
+        snapshot = snapshotRef.current;
+        if (!snapshot) {
+            throw new LocalSyncCoordinatorBrowserClientError('The local sync coordinator is not attached.', 'SYNC_COORDINATOR_UNAVAILABLE', 409);
+        }
         const envelope = {
             commandId: crypto.randomUUID(),
             workspaceId: input.workspaceId,
@@ -290,15 +335,28 @@ export function useLocalSyncCoordinatorSnapshot(input) {
         const lifecycle = {
             workspaceId: input.workspaceId,
             scope: scopeRef.current,
+            type,
             promise: commandPromise,
         };
         const lifecycleRef = priorityCommand
             ? priorityCommandLifecycleRef
             : commandLifecycleRef;
         lifecycleRef.current = lifecycle;
+        if (priorityCommand) {
+            setActivePriorityCommandType(type);
+        }
+        else {
+            setActiveCommandType(type);
+        }
         const finalize = () => {
             if (lifecycleRef.current === lifecycle) {
                 lifecycleRef.current = null;
+                if (priorityCommand) {
+                    setActivePriorityCommandType(null);
+                }
+                else {
+                    setActiveCommandType(null);
+                }
             }
             if (scopeRef.current === lifecycle.scope
                 && input.workspaceId === lifecycle.workspaceId) {
@@ -326,6 +384,18 @@ export function useLocalSyncCoordinatorSnapshot(input) {
         });
         return true;
     }, [client, input.workspaceId]);
+    const clearCredential = useCallback(async () => {
+        const snapshot = snapshotRef.current;
+        if (!snapshot || !input.workspaceId)
+            return false;
+        await client.clearCredential({
+            workspaceId: input.workspaceId,
+            coordinatorGeneration: snapshot.state.coordinatorGeneration,
+        });
+        snapshotRef.current = null;
+        setState({ phase: 'idle', snapshot: null, error: null });
+        return true;
+    }, [client, input.workspaceId]);
     const switchWorkspace = useCallback(async (targetWorkspaceId) => {
         const snapshot = snapshotRef.current;
         const expectedActiveWorkspaceId = String(snapshot?.state.activeWorkspaceId || '').trim();
@@ -381,12 +451,18 @@ export function useLocalSyncCoordinatorSnapshot(input) {
     }, [client, input.workspaceId, refresh]);
     return useMemo(() => ({
         ...state,
+        activeCommandType,
+        activePriorityCommandType,
         refresh,
         issueCommand,
         signalWake,
+        clearCredential,
         switchWorkspace,
         transferOwnership,
     }), [
+        activeCommandType,
+        activePriorityCommandType,
+        clearCredential,
         issueCommand,
         refresh,
         signalWake,

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

@@ -5,21 +5,24 @@ interface SaveWorkspaceCloudSyncSettingsResult {
 interface UseSyncStatusControlsInput {
     canManageWorkspaceSync: boolean;
     workspaceCloudSyncEnabled: boolean;
+    persistedToggleIntent?: WorkspaceSyncToggleIntent;
     saveWorkspaceCloudSyncSettings: (input: {
         enabled: boolean;
     }) => Promise<SaveWorkspaceCloudSyncSettingsResult>;
 }
+export type WorkspaceSyncToggleIntent = 'enabling' | 'disabling' | null;
 interface UseSyncStatusControlsResult {
     showSyncStatusModal: boolean;
     showSyncEnableWarning: boolean;
     workspaceSyncToggleBusy: boolean;
     workspaceSyncError: string | null;
     syncControlBusy: boolean;
+    syncControlIntent: WorkspaceSyncToggleIntent;
     openSyncStatusModal: () => void;
     closeSyncStatusModal: () => void;
     handleWorkspaceSyncToggle: (enabled: boolean) => Promise<void>;
     cancelSyncEnableWarning: () => void;
     confirmSyncEnableWarning: () => void;
 }
-export declare function useSyncStatusControls({ canManageWorkspaceSync, workspaceCloudSyncEnabled, saveWorkspaceCloudSyncSettings, }: UseSyncStatusControlsInput): UseSyncStatusControlsResult;
+export declare function useSyncStatusControls({ canManageWorkspaceSync, workspaceCloudSyncEnabled, persistedToggleIntent, saveWorkspaceCloudSyncSettings, }: UseSyncStatusControlsInput): UseSyncStatusControlsResult;
 export {};

package/dist/hooks/sync/useSyncStatusControls.js

@@ -1,23 +1,58 @@
-import { useCallback, useState } from 'react';
-export function useSyncStatusControls({ canManageWorkspaceSync, workspaceCloudSyncEnabled, saveWorkspaceCloudSyncSettings, }) {
+import { useCallback, useEffect, useRef, useState } from 'react';
+export function useSyncStatusControls({ canManageWorkspaceSync, workspaceCloudSyncEnabled, persistedToggleIntent = null, saveWorkspaceCloudSyncSettings, }) {
     const [showSyncStatusModal, setShowSyncStatusModal] = useState(false);
     const [showSyncEnableWarning, setShowSyncEnableWarning] = useState(false);
     const [workspaceSyncToggleBusy, setWorkspaceSyncToggleBusy] = useState(false);
     const [workspaceSyncError, setWorkspaceSyncError] = useState(null);
+    const [requestedSyncEnabled, setRequestedSyncEnabled] = useState(null);
+    const inFlightToggleRef = useRef(null);
+    const requestedToggleIntent = requestedSyncEnabled === null
+        ? null
+        : requestedSyncEnabled ? 'enabling' : 'disabling';
+    const syncControlIntent = requestedToggleIntent || persistedToggleIntent;
+    useEffect(() => {
+        if (requestedSyncEnabled !== null && requestedSyncEnabled === workspaceCloudSyncEnabled) {
+            setRequestedSyncEnabled(null);
+        }
+    }, [requestedSyncEnabled, workspaceCloudSyncEnabled]);
     const persistWorkspaceSyncToggle = useCallback(async (enabled) => {
         if (!canManageWorkspaceSync)
             return;
         setWorkspaceSyncError(null);
+        setRequestedSyncEnabled(enabled);
         setWorkspaceSyncToggleBusy(true);
-        try {
-            const result = await saveWorkspaceCloudSyncSettings({ enabled });
-            if (!result.success) {
-                setWorkspaceSyncError(result.error || (enabled ? 'Failed to enable sync.' : 'Failed to disable sync.'));
-            }
-        }
-        finally {
-            setWorkspaceSyncToggleBusy(false);
+        while (inFlightToggleRef.current) {
+            const active = inFlightToggleRef.current;
+            if (active.enabled === enabled)
+                return active.promise;
+            await active.promise;
         }
+        setRequestedSyncEnabled(enabled);
+        setWorkspaceSyncToggleBusy(true);
+        let commandPromise;
+        commandPromise = (async () => {
+            try {
+                const result = await saveWorkspaceCloudSyncSettings({ enabled });
+                if (!result.success) {
+                    setRequestedSyncEnabled(null);
+                    setWorkspaceSyncError(result.error || (enabled ? 'Failed to enable sync.' : 'Failed to disable sync.'));
+                }
+            }
+            catch (error) {
+                setRequestedSyncEnabled(null);
+                setWorkspaceSyncError(error instanceof Error && error.message.trim()
+                    ? error.message
+                    : enabled ? 'Failed to enable sync.' : 'Failed to disable sync.');
+            }
+            finally {
+                if (inFlightToggleRef.current?.promise === commandPromise) {
+                    inFlightToggleRef.current = null;
+                    setWorkspaceSyncToggleBusy(false);
+                }
+            }
+        })();
+        inFlightToggleRef.current = { enabled, promise: commandPromise };
+        return commandPromise;
     }, [
         canManageWorkspaceSync,
         saveWorkspaceCloudSyncSettings
@@ -50,7 +85,8 @@ export function useSyncStatusControls({ canManageWorkspaceSync, workspaceCloudSy
         showSyncEnableWarning,
         workspaceSyncToggleBusy,
         workspaceSyncError,
-        syncControlBusy: workspaceSyncToggleBusy,
+        syncControlBusy: workspaceSyncToggleBusy || syncControlIntent !== null,
+        syncControlIntent,
         openSyncStatusModal,
         closeSyncStatusModal,
         handleWorkspaceSyncToggle,

package/dist/hooks/useSyncOrchestrator.d.ts

@@ -79,9 +79,12 @@ export declare function useSyncOrchestrator(input: UseSyncOrchestratorInput): {
         phase: import("./sync/useLocalSyncCoordinatorSnapshot.js").LocalSyncCoordinatorSnapshotPhase;
         snapshot: import("../sync/coordinator/localSyncCoordinatorBrowserClient.js").LocalSyncCoordinatorStatusResponse | null;
         errorMessage: string | null;
+        activeCommandType: import("../sync/coordinator/localSyncCoordinatorTypes").LocalSyncCoordinatorCommandType | null;
+        activePriorityCommandType: import("../sync/coordinator/localSyncCoordinatorTypes").LocalSyncCoordinatorCommandType | null;
     } | null;
     switchLocalCoordinatorWorkspace: (targetWorkspaceId: string) => Promise<boolean>;
     transferLocalCoordinatorOwnership: (targetMode: "server" | "browser-gateway") => Promise<boolean>;
+    clearLocalCoordinatorCredential: () => Promise<boolean>;
     syncInFlightRef: import("react").RefObject<boolean>;
     workspaceRetryAt: string | null;
     isWorkspaceRetryPending: () => boolean;