feat: WebSocket temps réel + Finance Workflow + corrections

- Task #6: WebSocket /ws/dashboard + Kafka events (5 topics)
  * Backend: KafkaEventProducer, KafkaEventConsumer
  * Mobile: WebSocketService (reconnection, heartbeat, typed events)
  * DashboardBloc: Auto-refresh depuis WebSocket events

- Finance Workflow: approbations + budgets (backend + mobile)
  * Backend: entities, services, resources, migrations Flyway V6
  * Mobile: features finance_workflow complète avec BLoC

- Corrections DI: interfaces IRepository partout
  * IProfileRepository, IOrganizationRepository, IMembreRepository
  * GetIt configuré avec @injectable

- Spec-Kit: constitution + templates mis à jour
  * .specify/memory/constitution.md enrichie
  * Templates agent, plan, spec, tasks, checklist

- Nettoyage: fichiers temporaires supprimés

Signed-off-by: lions dev Team

unionflow/unionflow-mobile-apps/lib/features/communication/presentation/bloc/messaging_bloc.dart

@@ -0,0 +1,105 @@
+/// BLoC de gestion de la messagerie
+library messaging_bloc;
+
+import 'package:flutter_bloc/flutter_bloc.dart';
+import 'package:injectable/injectable.dart';
+import '../../domain/usecases/get_conversations.dart';
+import '../../domain/usecases/get_messages.dart';
+import '../../domain/usecases/send_message.dart';
+import '../../domain/usecases/send_broadcast.dart';
+import 'messaging_event.dart';
+import 'messaging_state.dart';
+
+@injectable
+class MessagingBloc extends Bloc<MessagingEvent, MessagingState> {
+  final GetConversations getConversations;
+  final GetMessages getMessages;
+  final SendMessage sendMessage;
+  final SendBroadcast sendBroadcast;
+
+  MessagingBloc({
+    required this.getConversations,
+    required this.getMessages,
+    required this.sendMessage,
+    required this.sendBroadcast,
+  }) : super(MessagingInitial()) {
+    on<LoadConversations>(_onLoadConversations);
+    on<LoadMessages>(_onLoadMessages);
+    on<SendMessageEvent>(_onSendMessage);
+    on<SendBroadcastEvent>(_onSendBroadcast);
+  }
+
+  Future<void> _onLoadConversations(
+    LoadConversations event,
+    Emitter<MessagingState> emit,
+  ) async {
+    emit(MessagingLoading());
+
+    final result = await getConversations(
+      organizationId: event.organizationId,
+      includeArchived: event.includeArchived,
+    );
+
+    result.fold(
+      (failure) => emit(MessagingError(failure.message)),
+      (conversations) => emit(ConversationsLoaded(conversations: conversations)),
+    );
+  }
+
+  Future<void> _onLoadMessages(
+    LoadMessages event,
+    Emitter<MessagingState> emit,
+  ) async {
+    emit(MessagingLoading());
+
+    final result = await getMessages(
+      conversationId: event.conversationId,
+      limit: event.limit,
+      beforeMessageId: event.beforeMessageId,
+    );
+
+    result.fold(
+      (failure) => emit(MessagingError(failure.message)),
+      (messages) => emit(MessagesLoaded(
+        conversationId: event.conversationId,
+        messages: messages,
+        hasMore: messages.length == (event.limit ?? 50),
+      )),
+    );
+  }
+
+  Future<void> _onSendMessage(
+    SendMessageEvent event,
+    Emitter<MessagingState> emit,
+  ) async {
+    final result = await sendMessage(
+      conversationId: event.conversationId,
+      content: event.content,
+      attachments: event.attachments,
+      priority: event.priority,
+    );
+
+    result.fold(
+      (failure) => emit(MessagingError(failure.message)),
+      (message) => emit(MessageSent(message)),
+    );
+  }
+
+  Future<void> _onSendBroadcast(
+    SendBroadcastEvent event,
+    Emitter<MessagingState> emit,
+  ) async {
+    final result = await sendBroadcast(
+      organizationId: event.organizationId,
+      subject: event.subject,
+      content: event.content,
+      priority: event.priority,
+      attachments: event.attachments,
+    );
+
+    result.fold(
+      (failure) => emit(MessagingError(failure.message)),
+      (message) => emit(BroadcastSent(message)),
+    );
+  }
+}