feat: add notification center with bell dropdown, full page, and workspace scoping (Story 3.3)

Enhance NotificationDropdown with type-specific icons, French description builder,
click-to-navigate with mark-as-read, and "Voir toutes les notifications" link.
Add full notifications page at /notifications with pagination (25/page), individual
mark-as-read, and empty state. Includes code review fixes: workspace-scoped unread
count and dropdown items, race condition fix (mark-as-read before navigate),
efficient markAllAsRead via direct update, deleted declaration URL handling,
and per-workspace cache keys. 7 new feature tests.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

_bmad-output/implementation-artifacts/3-3-notification-center-and-bell.md

@@ -0,0 +1,239 @@
+# Story 3.3: Notification Center & Bell
+
+Status: review
+
+## Story
+
+As a team member,
+I want to see a notification bell with unread count and access a notification center listing all my notifications,
+so that I never miss a nudge, alert, or important event and can navigate directly to the relevant declaration.
+
+## Acceptance Criteria
+
+1. **When user is logged in with unread notifications:**
+   - A NotificationBell component in the app sidebar header shows a badge with the unread notification count
+   - Clicking the bell opens a dropdown panel showing the 10 most recent notifications
+   - Each notification displays: type icon, description text, relative timestamp ("il y a 5 min"), and read/unread visual state
+   - Clicking a notification navigates to the relevant declaration detail page and marks the notification as read
+   - A "Tout marquer comme lu" action is available in the dropdown header
+   - A "Voir toutes les notifications" link at the bottom navigates to `/notifications`
+
+2. **When user navigates to `/notifications`:**
+   - All notifications are listed in reverse chronological order with pagination (25 per page)
+   - Each notification shows: type icon, full description, timestamp, and read/unread state
+   - Notifications can be marked as read individually or in bulk ("Tout marquer comme lu")
+   - Notifications are scoped to the current workspace (via `workspace_id` in notification data)
+
+3. **When user has zero notifications:**
+   - An EmptyState is shown: "Aucune notification"
+   - The bell badge is hidden (no "0" displayed)
+
+## Tasks / Subtasks
+
+- [x] Task 1: Enhance `NotificationDropdown.vue` bell component (AC: #1)
+  - [x] 1.1 Add type-specific icons per `NotificationType` (nudge → `Send`, declaration_overdue → `AlertTriangle`, document_uploaded → `FileUp`, status_changed → `RefreshCw`, bulk_notification → `Mail`)
+  - [x] 1.2 Improve notification item layout: icon + description + relative timestamp + unread blue dot
+  - [x] 1.3 Add click handler that navigates to declaration via `router.visit()` AND calls mark-as-read endpoint
+  - [x] 1.4 Add "Voir toutes les notifications" link at dropdown bottom navigating to `route('notifications.index')`
+  - [x] 1.5 Hide badge when unread_count is 0 (do not show "0")
+  - [x] 1.6 Ensure dropdown closes after clicking a notification
+
+- [x] Task 2: Enhance `/notifications` full page (AC: #2)
+  - [x] 2.1 Add type-specific icons matching dropdown icons
+  - [x] 2.2 Add click-to-navigate: clicking a notification row visits the declaration and marks it as read
+  - [x] 2.3 Add individual "mark as read" action per notification row
+  - [x] 2.4 Verify pagination works at 25 per page (already configured in controller)
+  - [x] 2.5 Add visual distinction for unread vs read notifications (background color or opacity)
+  - [x] 2.6 Format timestamps as relative ("il y a 5 min", "hier") — use `created_at` which is already `diffForHumans()` from middleware
+
+- [x] Task 3: Empty state handling (AC: #3)
+  - [x] 3.1 Show "Aucune notification" with Bell icon in dropdown when items array is empty
+  - [x] 3.2 Show "Aucune notification pour le moment" on full page when no notifications exist (verify existing empty state)
+
+- [x] Task 4: Update TypeScript types if needed (AC: #1, #2)
+  - [x] 4.1 Ensure `NotificationData` type covers all notification payloads (declaration_id, sender_id, client_id)
+  - [x] 4.2 Add icon mapping utility or computed property for `NotificationType` → Lucide icon component
+
+- [x] Task 5: Write feature tests (AC: #1, #2, #3)
+  - [x] 5.1 Test: notification dropdown renders with unread count badge
+  - [x] 5.2 Test: clicking notification marks it as read (POST to `notifications.read`)
+  - [x] 5.3 Test: mark all as read clears unread count
+  - [x] 5.4 Test: notifications page renders with workspace-scoped notifications
+  - [x] 5.5 Test: notifications page pagination works at 25 per page
+  - [x] 5.6 Test: empty state renders when no notifications exist
+  - [x] 5.7 Test: notifications are scoped to current workspace (cross-workspace isolation)
+
+## Retrospective Intelligence
+
+- **Team Agreement (Epic 2 Retro — non-negotiable):** Load retrospective as context during story creation ✅
+- **Pre-existing test failures (A2):** 15 failures were resolved in commit `716e9fc` before Epic 3 started — baseline is clean
+- **Architecture doc drift (A4):** `due_date` not `deadline`, no `Declaration::workspace()` scope, `mise_en_demeure` status undocumented — all corrected in commit `6956f7b`
+- **withPivot gotcha (Epics 1 & 2):** Always chain `->withPivot('role', 'permissions')` on workspace relationships — documented in project-context.md
+- **D-1 (Deferred from Epic 2):** Dashboard "Relancer" dropdown was disabled — resolved in Story 3.2
+- **D-2:** StatCard `assignee` param intentional — no action needed
+- **D-3:** Cache not invalidated on role change — 5-min TTL mitigates, low severity
+- **Code review remains mandatory** — run after implementation
+- **`withoutVite()` global workaround** in Pest.php confirmed compatible — no action needed for tests
+
+## Dev Notes
+
+### CRITICAL: Existing Infrastructure — DO NOT Recreate
+
+Story 3.3 builds on top of **existing components from Stories 3.1 and 3.2**. The dev agent MUST enhance, not replace:
+
+| Component | File | Status | What to do |
+|-----------|------|--------|------------|
+| `NotificationDropdown.vue` | `resources/js/components/NotificationDropdown.vue` | EXISTS | Enhance with type icons, click-to-navigate, "View all" link |
+| `notifications/Index.vue` | `resources/js/pages/notifications/Index.vue` | EXISTS | Enhance with type icons, click-to-read, individual mark-as-read |
+| `NotificationController` | `app/Http/Controllers/NotificationController.php` | EXISTS | Already has `index()`, `markAsRead()`, `markAllAsRead()` — may need minor updates |
+| Routes | `routes/web.php` | EXISTS | `GET /notifications`, `POST /notifications/{id}/read`, `POST /notifications/mark-all-read` all registered |
+| Inertia middleware | `app/Http/Middleware/HandleInertiaRequests.php` | EXISTS | Shares `userNotifications` prop (unread_count, readUrl, readAllUrl, items via `Inertia::defer`) |
+| TypeScript types | `resources/js/types/notification.ts` | EXISTS | `AppNotification`, `NotificationData`, `NotificationType` types defined |
+| `NotificationType` enum | `app/Enums/NotificationType.php` | EXISTS | 5 values with French labels |
+| Cache pattern | Multiple controllers | EXISTS | `Cache::forget("user:{$userId}:unread_notifications")` |
+
+### Inertia Shared Props (Already Wired)
+
+The `HandleInertiaRequests.php` middleware already shares on every page:
+
+```php
+'userNotifications' => [
+    'unread_count' => Cache::remember("user:{$user->id}:unread_notifications", 60, ...),
+    'readUrl' => route('notifications.read', ['id' => '__ID__']),
+    'readAllUrl' => route('notifications.readAll'),
+    'items' => Inertia::defer(fn () => [...10 most recent...])
+]
+```
+
+The `readUrl` uses `__ID__` placeholder — replace in frontend with actual notification ID when calling.
+
+### Icon Mapping for Notification Types
+
+Use `lucide-vue-next` icons (already installed):
+
+| NotificationType | Icon | Import |
+|-----------------|------|--------|
+| `nudge` | `Send` | `import { Send } from 'lucide-vue-next'` |
+| `declaration_overdue` | `AlertTriangle` | `import { AlertTriangle } from 'lucide-vue-next'` |
+| `document_uploaded` | `FileUp` | `import { FileUp } from 'lucide-vue-next'` |
+| `bulk_notification` | `Mail` | `import { Mail } from 'lucide-vue-next'` |
+| `status_changed` | `RefreshCw` | `import { RefreshCw } from 'lucide-vue-next'` |
+
+### Click-to-Navigate Pattern
+
+When a notification is clicked, two things must happen:
+1. **Mark as read:** POST to `readUrl.replace('__ID__', notification.id)` — use `router.post()` from `@inertiajs/vue3`
+2. **Navigate to declaration:** `router.visit(route('declarations.show', notification.data.declaration_id))`
+
+Handle both in sequence — mark as read first, then navigate. Or combine: the mark-as-read endpoint can redirect to the declaration. Check current `NotificationController@markAsRead` implementation.
+
+### Workspace Scoping
+
+All notification queries are already workspace-scoped via:
+```php
+->whereJsonContains('data->workspace_id', $workspace->id)
+```
+
+This is implemented in `NotificationController@index` and `HandleInertiaRequests` middleware. No additional scoping needed in frontend — data arrives pre-filtered.
+
+### Description Text Generation
+
+Build notification description from `notification.data` and `notification.type`:
+- `NudgeNotification` → "Relance de {sender_name} sur {declaration_title}"
+- `DeclarationOverdueNotification` → "Déclaration en retard : {declaration_title}"
+- `DocumentUploadedNotification` → "Document téléversé pour {declaration_title}"
+- `StatusChangedNotification` → "Statut modifié : {declaration_title}"
+
+Note: The existing `NotificationDropdown.vue` already has some description logic — extend it, don't replace.
+
+### Testing Standards
+
+- **Framework:** Pest PHP syntax with `RefreshDatabase`
+- **URL generation:** Always use `route()` helper, never hardcode URLs
+- **Auth setup:** Use `$this->actingAs($user)` with workspace session set
+- **Notification factory:** Use `$user->notify(new NudgeNotification($declaration, $sender))` to seed test data
+- **Assertions:** `assertInertia()` for page rendering, check notification props
+- **Test file:** `tests/Feature/Notifications/NotificationCenterTest.php` (new file)
+- **Baseline:** 247 tests passing — zero regressions allowed
+
+### Established Code Patterns (from Stories 3.1 & 3.2)
+
+**Controller authorization:**
+```php
+$workspace = $this->currentWorkspace();
+// Use HasWorkspaceScope trait
+$this->authorizeWorkspaceAccess($model); // aborts 404 if wrong workspace
+```
+
+**Cache invalidation after state change:**
+```php
+Cache::forget("user:{$userId}:unread_notifications");
+```
+
+**Flash messages:**
+```php
+return back()->with('flash', ['type' => 'success', 'message' => '...']);
+```
+
+**Vue component pattern:**
+```vue
+<script setup lang="ts">
+import { router, usePage } from '@inertiajs/vue3';
+import type { AppNotification } from '@/types/notification';
+// Always <script setup lang="ts">, never Options API
+</script>
+```
+
+### Project Structure Notes
+
+- Frontend components: `resources/js/components/` for reusable, `resources/js/pages/` for route pages
+- Sidebar header: `resources/js/components/AppSidebarHeader.vue` — where `NotificationDropdown` is mounted
+- UI primitives: `resources/js/components/ui/` — shadcn-vue components (popover, button, dropdown, etc.)
+- Type definitions: `resources/js/types/` — TypeScript types with `import type` for type-only imports
+- Inertia render paths use lowercase subdirectories: `'notifications/Index'`
+
+### References
+
+- [Source: _bmad-output/planning-artifacts/epics.md — Epic 3, Story 3.3]
+- [Source: _bmad-output/planning-artifacts/architecture.md — D8: In-App Notification System, D10: Real-Time Features]
+- [Source: _bmad-output/planning-artifacts/ux-design-specification.md — Notification Bell, Notification Patterns]
+- [Source: _bmad-output/planning-artifacts/prd.md — FR30, FR31]
+- [Source: _bmad-output/implementation-artifacts/3-1-notification-infrastructure-setup.md]
+- [Source: _bmad-output/implementation-artifacts/3-2-one-click-nudge-system.md]
+- [Source: _bmad-output/implementation-artifacts/epic-2-retro-2026-03-24.md — D-1, Team Agreements]
+- [Source: _bmad-output/project-context.md — Gotchas, Tech Stack]
+
+## Dev Agent Record
+
+### Agent Model Used
+
+Claude Opus 4.6 (1M context)
+
+### Debug Log References
+
+- Initial NudgeNotification tests failed due to mail channel sending real emails — fixed by adding `Mail::fake()` to test setup
+- Pagination links type in Index.vue needed proper typing for `url`, `label`, `active` fields
+- Used `notifications.through()` for controller data enrichment to work with Laravel's paginator
+
+### Completion Notes List
+
+- **Task 4 (Types):** Extended `NotificationData` type with `declaration_title`, `sender_name`, `url` fields for enriched display data
+- **Backend enrichment:** Added notification data enrichment in both `HandleInertiaRequests` middleware (dropdown) and `NotificationController@index` (full page) — batch-loads declaration titles and sender names via 2 queries to avoid N+1
+- **Task 1 (Dropdown):** Rewrote `NotificationDropdown.vue` with type-specific Lucide icons per NotificationType, French description text builder, click-to-navigate with mark-as-read, "Tout marquer comme lu" in header, "Voir toutes les notifications" link, badge hidden when count is 0
+- **Task 2 (Full page):** Enhanced `notifications/Index.vue` with type icons, clickable rows that navigate + mark-as-read, individual "Marquer lu" button per row, unread/read visual distinction (background + opacity), proper pagination controls
+- **Task 3 (Empty states):** Dropdown shows Bell icon + "Aucune notification" when empty; full page shows Bell icon + "Aucune notification pour le moment" (preserved existing pattern)
+- **Task 5 (Tests):** Created 7 feature tests in `NotificationCenterTest.php` covering all ACs — dropdown shared props, mark-as-read, mark-all-read, full page rendering, pagination at 25/page, empty state, cross-workspace isolation
+- **Regression check:** 254 tests pass (up from 247 baseline + 7 new), zero failures
+
+### Change Log
+
+- 2026-03-26: Implemented Story 3.3 — Notification Center & Bell enhancements (all 5 tasks, 7 new tests)
+
+### File List
+
+- `resources/js/types/notification.ts` — Modified: added `declaration_title`, `sender_name`, `url` to `NotificationData`
+- `resources/js/components/NotificationDropdown.vue` — Modified: type icons, description builder, click-navigate, "View all" link, empty state
+- `resources/js/pages/notifications/Index.vue` — Modified: type icons, click-navigate, individual mark-read, pagination, visual distinction
+- `app/Http/Middleware/HandleInertiaRequests.php` — Modified: enriched notification items with declaration titles/sender names/URLs, added `notificationsUrl` shared prop
+- `app/Http/Controllers/NotificationController.php` — Modified: enriched notification data in index(), added `readUrl` prop
+- `tests/Feature/Notifications/NotificationCenterTest.php` — New: 7 feature tests for notification center

_bmad-output/implementation-artifacts/sprint-status.yaml

@@ -34,7 +34,7 @@
 # - Dev moves story to 'review', then runs code-review (fresh context, different LLM recommended)
 
 generated: 2026-03-11
-last_updated: 2026-03-24T00:00:00
+last_updated: "2026-03-26"
 project: "l'ami fiduciaire"
 project_key: NOKEY
 tracking_system: file-system
@@ -69,10 +69,10 @@ development_status:
   epic-2-retrospective: done
 
   # Epic 3: Collaboration, Nudge System & Notifications
-  epic-3: backlog
+  epic-3: in-progress
-  3-1-notification-infrastructure-setup: backlog
+  3-1-notification-infrastructure-setup: done
-  3-2-one-click-nudge-system: backlog
+  3-2-one-click-nudge-system: done
-  3-3-notification-center-and-bell: backlog
+  3-3-notification-center-and-bell: review
   3-4-bulk-client-notification-scheduling: backlog
   3-5-email-notification-enhancement-for-key-events: backlog
   epic-3-retrospective: optional

app/Http/Controllers/DeclarationMentionController.php

@@ -52,7 +52,7 @@ class DeclarationMentionController extends Controller
             $validated['message'],
         ));
 
-        Cache::forget("user:{$targetUser->id}:unread_notifications");
+        Cache::forget("user:{$targetUser->id}:workspace:{$workspace->id}:unread_notifications");
 
         return back()->with('flash', ['type' => 'success', 'message' => 'Notification envoyée.']);
     }

app/Http/Controllers/FolderMentionController.php

@@ -52,7 +52,7 @@ class FolderMentionController extends Controller
             $validated['message'],
         ));
 
-        Cache::forget("user:{$targetUser->id}:unread_notifications");
+        Cache::forget("user:{$targetUser->id}:workspace:{$workspace->id}:unread_notifications");
 
         return back()->with('flash', ['type' => 'success', 'message' => 'Notification envoyée.']);
     }

app/Http/Controllers/NotificationController.php

@@ -2,12 +2,61 @@
 
 namespace App\Http\Controllers;
 
+use App\Concerns\HasWorkspaceScope;
+use App\Models\Declaration;
+use App\Models\User;
 use Illuminate\Http\RedirectResponse;
 use Illuminate\Http\Request;
 use Illuminate\Support\Facades\Cache;
+use Inertia\Inertia;
+use Inertia\Response;
 
 class NotificationController extends Controller
 {
+    use HasWorkspaceScope;
+
+    public function index(Request $request): Response
+    {
+        $workspace = $this->currentWorkspace();
+
+        $notifications = $request->user()
+            ->notifications()
+            ->whereJsonContains('data->workspace_id', $workspace->id)
+            ->latest()
+            ->paginate(25);
+
+        $declarationIds = collect($notifications->items())->pluck('data.declaration_id')->filter()->unique()->values();
+        $senderIds = collect($notifications->items())->pluck('data.sender_id')->filter()->unique()->values();
+
+        $declarations = Declaration::whereIn('id', $declarationIds)->pluck('title', 'id');
+        $senders = User::whereIn('id', $senderIds)->pluck('name', 'id');
+
+        $notifications->through(function ($n) use ($declarations, $senders) {
+            $data = $n->data;
+            $declarationId = $data['declaration_id'] ?? null;
+            $senderId = $data['sender_id'] ?? null;
+
+            $declarationExists = $declarationId && isset($declarations[$declarationId]);
+            $data['declaration_title'] = $declarationExists ? $declarations[$declarationId] : null;
+            $data['sender_name'] = $senderId ? ($senders[$senderId] ?? null) : null;
+            $data['url'] = $declarationExists ? route('declarations.show', $declarationId) : null;
+
+            return [
+                'id' => $n->id,
+                'type' => class_basename($n->type),
+                'data' => $data,
+                'read_at' => $n->read_at?->toISOString(),
+                'created_at' => $n->created_at->diffForHumans(),
+            ];
+        });
+
+        return Inertia::render('notifications/Index', [
+            'notifications' => $notifications,
+            'markAllReadUrl' => route('notifications.readAll'),
+            'readUrl' => route('notifications.read', ['id' => '__ID__']),
+        ]);
+    }
+
     public function markAsRead(Request $request, string $id): RedirectResponse
     {
         $request->user()
@@ -16,16 +65,22 @@ class NotificationController extends Controller
             ->firstOrFail()
             ->markAsRead();
 
-        Cache::forget("user:{$request->user()->id}:unread_notifications");
+        $workspaceId = $request->session()->get('current_workspace_id');
+        Cache::forget("user:{$request->user()->id}:workspace:{$workspaceId}:unread_notifications");
 
         return back();
     }
 
     public function markAllAsRead(Request $request): RedirectResponse
     {
-        $request->user()->unreadNotifications->markAsRead();
+        $workspace = $this->currentWorkspace();
 
-        Cache::forget("user:{$request->user()->id}:unread_notifications");
+        $request->user()
+            ->unreadNotifications()
+            ->whereJsonContains('data->workspace_id', $workspace->id)
+            ->update(['read_at' => now()]);
+
+        Cache::forget("user:{$request->user()->id}:workspace:{$workspace->id}:unread_notifications");
 
         return back();
     }

app/Http/Middleware/HandleInertiaRequests.php

@@ -2,6 +2,8 @@
 
 namespace App\Http\Middleware;
 
+use App\Models\Declaration;
+use App\Models\User;
 use App\Models\WorkspaceUser;
 use Illuminate\Http\Request;
 use Illuminate\Support\Facades\Cache;
@@ -81,26 +83,52 @@ class HandleInertiaRequests extends Middleware
             ],
             'sidebarOpen' => ! $request->hasCookie('sidebar_state') || $request->cookie('sidebar_state') === 'true',
             'userNotifications' => [
-                'unread_count' => $user ? Cache::remember(
+                'unread_count' => $user && $currentWorkspace ? Cache::remember(
-                    "user:{$user->id}:unread_notifications",
+                    "user:{$user->id}:workspace:{$currentWorkspace['id']}:unread_notifications",
                     60,
-                    fn () => $user->unreadNotifications()->count()
+                    fn () => $user->unreadNotifications()
+                        ->whereJsonContains('data->workspace_id', $currentWorkspace['id'])
+                        ->count()
                 ) : 0,
                 'readUrl' => fn () => $user ? route('notifications.read', ['id' => '__ID__']) : null,
                 'readAllUrl' => fn () => $user ? route('notifications.readAll') : null,
-                'items' => Inertia::defer(function () use ($user) {
+                'notificationsUrl' => fn () => $user ? route('notifications.index') : null,
-                    if (! $user) {
+                'items' => Inertia::defer(function () use ($user, $currentWorkspace) {
+                    if (! $user || ! $currentWorkspace) {
                         return [];
                     }
 
                     try {
-                        return $user->notifications()->latest()->take(10)->get()->map(fn ($n) => [
+                        $notifications = $user->notifications()
-                            'id' => $n->id,
+                            ->whereJsonContains('data->workspace_id', $currentWorkspace['id'])
-                            'type' => class_basename($n->type),
+                            ->latest()
-                            'data' => $n->data,
+                            ->take(10)
-                            'read_at' => $n->read_at?->toISOString(),
+                            ->get();
-                            'created_at' => $n->created_at->diffForHumans(),
+
-                        ])->all();
+                        $declarationIds = $notifications->pluck('data.declaration_id')->filter()->unique()->values();
+                        $senderIds = $notifications->pluck('data.sender_id')->filter()->unique()->values();
+
+                        $declarations = Declaration::whereIn('id', $declarationIds)->pluck('title', 'id');
+                        $senders = User::whereIn('id', $senderIds)->pluck('name', 'id');
+
+                        return $notifications->map(function ($n) use ($declarations, $senders) {
+                            $data = $n->data;
+                            $declarationId = $data['declaration_id'] ?? null;
+                            $senderId = $data['sender_id'] ?? null;
+
+                            $declarationExists = $declarationId && isset($declarations[$declarationId]);
+                            $data['declaration_title'] = $declarationExists ? $declarations[$declarationId] : null;
+                            $data['sender_name'] = $senderId ? ($senders[$senderId] ?? null) : null;
+                            $data['url'] = $declarationExists ? route('declarations.show', $declarationId) : null;
+
+                            return [
+                                'id' => $n->id,
+                                'type' => class_basename($n->type),
+                                'data' => $data,
+                                'read_at' => $n->read_at?->toISOString(),
+                                'created_at' => $n->created_at->diffForHumans(),
+                            ];
+                        })->all();
                     } catch (\Throwable) {
                         return [];
                     }

resources/js/components/NotificationDropdown.vue

@@ -1,6 +1,13 @@
 <script setup lang="ts">
 import { router, usePage } from '@inertiajs/vue3';
-import { Bell } from 'lucide-vue-next';
+import {
+    AlertTriangle,
+    Bell,
+    FileUp,
+    Mail,
+    RefreshCw,
+    Send,
+} from 'lucide-vue-next';
 import { computed } from 'vue';
 import { Button } from '@/components/ui/button';
 import {
@@ -11,15 +18,16 @@ import {
     DropdownMenuSeparator,
     DropdownMenuTrigger,
 } from '@/components/ui/dropdown-menu';
+import type { NotificationType } from '@/types/notification';
 
 type NotificationItem = {
     id: string;
     type: string;
     data: {
+        notification_type?: NotificationType;
         declaration_id?: number;
         declaration_title?: string;
-        mentioned_by_name?: string;
+        sender_name?: string;
-        message?: string;
         url?: string;
     };
     read_at: string | null;
@@ -30,9 +38,18 @@ type UserNotifications = {
     unread_count: number;
     readUrl: string | null;
     readAllUrl: string | null;
+    notificationsUrl: string | null;
     items: NotificationItem[] | undefined;
 };
 
+const iconMap: Record<NotificationType, typeof Send> = {
+    nudge: Send,
+    declaration_overdue: AlertTriangle,
+    document_uploaded: FileUp,
+    bulk_notification: Mail,
+    status_changed: RefreshCw,
+};
+
 const page = usePage();
 
 const userNotifications = computed<UserNotifications>(() => {
@@ -44,32 +61,64 @@ const unreadCount = computed(() => userNotifications.value?.unread_count ?? 0);
 const items = computed(() => userNotifications.value?.items ?? []);
 const isLoading = computed(() => userNotifications.value?.items === undefined);
 
+function getIcon(notificationType?: NotificationType) {
+    if (!notificationType) return Bell;
+    return iconMap[notificationType] ?? Bell;
+}
+
+function getDescription(notification: NotificationItem): string {
+    const type = notification.data?.notification_type;
+    const title = notification.data?.declaration_title ?? 'Déclaration';
+    const sender = notification.data?.sender_name;
+
+    switch (type) {
+        case 'nudge':
+            return sender
+                ? `Relance de ${sender} sur ${title}`
+                : `Relance sur ${title}`;
+        case 'declaration_overdue':
+            return `Déclaration en retard : ${title}`;
+        case 'document_uploaded':
+            return `Document téléversé pour ${title}`;
+        case 'status_changed':
+            return `Statut modifié : ${title}`;
+        case 'bulk_notification':
+            return `Notification groupée : ${title}`;
+        default:
+            return title;
+    }
+}
+
 function markAsRead(notification: NotificationItem) {
     const readUrl = userNotifications.value?.readUrl;
     if (!readUrl) return;
 
-    // Replace __ID__ placeholder with actual notification ID
-    // This is a convention: the server provides a URL template with __ID__ as placeholder
     const url = readUrl.replace('__ID__', notification.id);
     router.post(url, {}, { preserveScroll: true });
 }
 
 function navigateToNotification(notification: NotificationItem) {
     const targetUrl = notification.data?.url;
-    if (!targetUrl) return;
 
     if (!notification.read_at) {
-        markAsRead(notification);
+        const readUrl = userNotifications.value?.readUrl;
+        if (readUrl) {
+            const url = readUrl.replace('__ID__', notification.id);
+            router.post(url, {}, {
+                preserveScroll: true,
+                onSuccess: () => {
+                    if (targetUrl) {
+                        router.visit(targetUrl);
+                    }
+                },
+            });
+            return;
+        }
     }
 
-    router.visit(targetUrl, {
+    if (targetUrl) {
-        onError: () => {
+        router.visit(targetUrl);
-            // Declaration may have been deleted — mark as read anyway
+    }
-            if (!notification.read_at) {
-                markAsRead(notification);
-            }
-        },
-    });
 }
 
 function markAllAsRead() {
@@ -78,6 +127,13 @@ function markAllAsRead() {
 
     router.post(readAllUrl, {}, { preserveScroll: true });
 }
+
+function navigateToAll() {
+    const url = userNotifications.value?.notificationsUrl;
+    if (url) {
+        router.visit(url);
+    }
+}
 </script>
 
 <template>
@@ -94,7 +150,18 @@ function markAllAsRead() {
             </Button>
         </DropdownMenuTrigger>
         <DropdownMenuContent align="end" class="w-80">
-            <DropdownMenuLabel>Notifications</DropdownMenuLabel>
+            <div class="flex items-center justify-between px-2 py-1.5">
+                <DropdownMenuLabel class="p-0">
+                    Notifications
+                </DropdownMenuLabel>
+                <button
+                    v-if="unreadCount > 0"
+                    class="text-xs text-muted-foreground hover:text-foreground"
+                    @click.stop="markAllAsRead"
+                >
+                    Tout marquer comme lu
+                </button>
+            </div>
             <DropdownMenuSeparator />
 
             <div
@@ -106,57 +173,50 @@ function markAllAsRead() {
 
             <div
                 v-else-if="!items.length"
-                class="px-2 py-4 text-center text-sm text-muted-foreground"
+                class="flex flex-col items-center gap-2 px-2 py-6 text-center text-sm text-muted-foreground"
             >
-                Aucune notification.
+                <Bell class="size-8 text-muted-foreground/50" />
+                Aucune notification
             </div>
 
             <template v-else>
                 <DropdownMenuItem
                     v-for="notification in items"
                     :key="notification.id"
-                    class="flex cursor-pointer flex-col items-start gap-1 p-3"
+                    class="flex cursor-pointer items-start gap-3 p-3"
-                    :class="{ 'opacity-50': notification.read_at }"
+                    :class="{
+                        'bg-muted/50': !notification.read_at,
+                        'opacity-60': notification.read_at,
+                    }"
                     @click="navigateToNotification(notification)"
                 >
-                    <div class="flex w-full items-center justify-between gap-2">
+                    <component
-                        <span class="text-xs font-medium">
+                        :is="getIcon(notification.data?.notification_type)"
-                            {{
+                        class="mt-0.5 size-4 shrink-0 text-muted-foreground"
-                                notification.data?.mentioned_by_name ??
+                    />
-                                'Système'
+                    <div class="flex-1 space-y-1">
-                            }}
+                        <p class="text-xs leading-snug">
-                        </span>
+                            {{ getDescription(notification) }}
-                        <span class="text-xs text-muted-foreground">
+                        </p>
+                        <p class="text-xs text-muted-foreground">
                             {{ notification.created_at }}
-                        </span>
+                        </p>
                     </div>
-                    <p class="text-xs text-muted-foreground">
-                        <span
-                            v-if="notification.data?.declaration_title"
-                            class="font-medium text-foreground"
-                        >
-                            {{ notification.data.declaration_title }}
-                        </span>
-                        {{
-                            notification.data?.message
-                                ? ` — ${notification.data.message}`
-                                : ''
-                        }}
-                    </p>
                     <span
                         v-if="!notification.read_at"
-                        class="size-1.5 rounded-full bg-primary"
+                        class="mt-1 size-2 shrink-0 rounded-full bg-primary"
                     />
                 </DropdownMenuItem>
+
             </template>
 
-            <DropdownMenuSeparator v-if="items.length > 0" />
+            <DropdownMenuSeparator v-if="!isLoading" />
             <DropdownMenuItem
-                v-if="unreadCount > 0"
+                v-if="!isLoading"
                 class="justify-center text-xs text-muted-foreground"
-                @click="markAllAsRead"
+                @click="navigateToAll"
             >
-                Marquer tout comme lu
+                Voir toutes les notifications
             </DropdownMenuItem>
         </DropdownMenuContent>
     </DropdownMenu>

resources/js/pages/notifications/Index.vue

@@ -0,0 +1,199 @@
+<script setup lang="ts">
+import { Head, router } from '@inertiajs/vue3';
+import { computed } from 'vue';
+import {
+    AlertTriangle,
+    Bell,
+    CheckCheck,
+    FileUp,
+    Mail,
+    RefreshCw,
+    Send,
+} from 'lucide-vue-next';
+import Heading from '@/components/Heading.vue';
+import { Button } from '@/components/ui/button';
+import AppLayout from '@/layouts/AppLayout.vue';
+import type { AppNotification, NotificationType } from '@/types/notification';
+
+type Props = {
+    notifications: {
+        data: AppNotification[];
+        links: { url: string | null; label: string; active: boolean }[];
+        current_page: number;
+        last_page: number;
+    };
+    markAllReadUrl: string;
+    readUrl: string;
+};
+
+const props = defineProps<Props>();
+
+const hasUnread = computed(() =>
+    props.notifications.data.some((n) => !n.read_at),
+);
+
+const iconMap: Record<NotificationType, typeof Send> = {
+    nudge: Send,
+    declaration_overdue: AlertTriangle,
+    document_uploaded: FileUp,
+    bulk_notification: Mail,
+    status_changed: RefreshCw,
+};
+
+function getIcon(notificationType?: NotificationType) {
+    if (!notificationType) return Bell;
+    return iconMap[notificationType] ?? Bell;
+}
+
+function getDescription(notification: AppNotification): string {
+    const type = notification.data?.notification_type;
+    const title = notification.data?.declaration_title ?? 'Déclaration';
+    const sender = notification.data?.sender_name;
+
+    switch (type) {
+        case 'nudge':
+            return sender
+                ? `Relance de ${sender} sur ${title}`
+                : `Relance sur ${title}`;
+        case 'declaration_overdue':
+            return `Déclaration en retard : ${title}`;
+        case 'document_uploaded':
+            return `Document téléversé pour ${title}`;
+        case 'status_changed':
+            return `Statut modifié : ${title}`;
+        case 'bulk_notification':
+            return `Notification groupée : ${title}`;
+        default:
+            return title;
+    }
+}
+
+function markAllRead() {
+    router.post(props.markAllReadUrl);
+}
+
+function markAsRead(notification: AppNotification) {
+    if (notification.read_at) return;
+
+    const url = props.readUrl.replace('__ID__', notification.id);
+    router.post(url, {}, { preserveScroll: true });
+}
+
+function navigateToNotification(notification: AppNotification) {
+    const targetUrl = notification.data?.url;
+
+    if (!notification.read_at) {
+        const url = props.readUrl.replace('__ID__', notification.id);
+        router.post(url, {}, {
+            preserveScroll: true,
+            onSuccess: () => {
+                if (targetUrl) {
+                    router.visit(targetUrl);
+                }
+            },
+        });
+        return;
+    }
+
+    if (targetUrl) {
+        router.visit(targetUrl);
+    }
+}
+
+function goToPage(url: string | null) {
+    if (url) {
+        router.visit(url);
+    }
+}
+</script>
+
+<template>
+    <AppLayout :breadcrumbs="[{ title: 'Notifications', href: '#' }]">
+        <Head title="Notifications" />
+
+        <div class="flex items-center justify-between">
+            <Heading
+                title="Notifications"
+                description="Consultez vos notifications."
+            />
+            <Button
+                v-if="hasUnread"
+                variant="outline"
+                size="sm"
+                @click="markAllRead"
+            >
+                <CheckCheck class="mr-1.5 size-4" />
+                Tout marquer comme lu
+            </Button>
+        </div>
+
+        <div
+            v-if="notifications.data.length === 0"
+            class="mt-8 flex flex-col items-center justify-center py-12 text-center"
+        >
+            <Bell class="mb-4 h-12 w-12 text-muted-foreground" />
+            <p class="text-muted-foreground">
+                Aucune notification
+            </p>
+        </div>
+
+        <div v-else class="mt-6 space-y-2">
+            <div
+                v-for="notification in notifications.data"
+                :key="notification.id"
+                class="flex cursor-pointer items-start gap-4 rounded-lg border p-4 transition-colors hover:bg-muted/30"
+                :class="{
+                    'border-primary/20 bg-muted/50': !notification.read_at,
+                    'opacity-70': notification.read_at,
+                }"
+                @click="navigateToNotification(notification)"
+            >
+                <component
+                    :is="getIcon(notification.data?.notification_type)"
+                    class="mt-0.5 size-5 shrink-0 text-muted-foreground"
+                />
+                <div class="flex-1 space-y-1">
+                    <p class="text-sm font-medium">
+                        {{ getDescription(notification) }}
+                    </p>
+                    <p class="text-xs text-muted-foreground">
+                        {{ notification.created_at }}
+                    </p>
+                </div>
+                <div class="flex shrink-0 items-center gap-2">
+                    <button
+                        v-if="!notification.read_at"
+                        class="text-xs text-muted-foreground hover:text-foreground"
+                        @click.stop="markAsRead(notification)"
+                    >
+                        Marquer lu
+                    </button>
+                    <span
+                        v-if="!notification.read_at"
+                        class="size-2 rounded-full bg-primary"
+                    />
+                </div>
+            </div>
+
+            <!-- Pagination -->
+            <div
+                v-if="notifications.last_page > 1"
+                class="flex items-center justify-center gap-2 pt-4"
+            >
+                <template
+                    v-for="(link, index) in notifications.links"
+                    :key="index"
+                >
+                    <Button
+                        v-if="link.url || link.active"
+                        variant="outline"
+                        size="sm"
+                        :disabled="!link.url || link.active"
+                        @click="goToPage(link.url)"
+                        v-html="link.label"
+                    />
+                </template>
+            </div>
+        </div>
+    </AppLayout>
+</template>

resources/js/types/index.ts

@@ -1,5 +1,6 @@
 export * from './auth';
 export * from './dashboard';
 export * from './navigation';
+export * from './notification';
 export * from './team';
 export * from './ui';

resources/js/types/notification.ts

@@ -0,0 +1,26 @@
+export type NotificationType =
+    | 'nudge'
+    | 'declaration_overdue'
+    | 'document_uploaded'
+    | 'bulk_notification'
+    | 'status_changed';
+
+export type NotificationData = {
+    workspace_id: number;
+    notification_type: NotificationType;
+    declaration_id?: number;
+    sender_id?: number;
+    client_id?: number;
+    declaration_title?: string;
+    sender_name?: string;
+    url?: string;
+};
+
+export type AppNotification = {
+    id: string;
+    type: string;
+    data: NotificationData;
+    read_at: string | null;
+    created_at: string;
+    updated_at: string;
+};

tests/Feature/Notifications/NotificationCenterTest.php

@@ -0,0 +1,156 @@
+<?php
+
+use App\Models\Declaration;
+use App\Models\User;
+use App\Models\Workspace;
+use App\Notifications\DocumentUploadedNotification;
+use App\Notifications\NudgeNotification;
+use Illuminate\Support\Facades\Mail;
+use Inertia\Testing\AssertableInertia;
+
+function setupNotificationCenterTest(): array
+{
+    Mail::fake();
+
+    $user = User::factory()->create();
+    $workspace = Workspace::factory()->create();
+    $workspace->users()->attach($user->id, ['role' => 'owner', 'permissions' => []]);
+
+    session(['current_workspace_id' => $workspace->id]);
+
+    $declaration = Declaration::factory()->forWorkspace($workspace)->create();
+
+    return [$user, $workspace, $declaration];
+}
+
+// ── AC #1: Dropdown rendering ────────────────────────────
+
+test('notification dropdown renders with unread count badge via shared props', function () {
+    [$user, $workspace, $declaration] = setupNotificationCenterTest();
+    $sender = User::factory()->create();
+
+    $user->notify(new NudgeNotification($declaration, $sender));
+    $user->notify(new NudgeNotification($declaration, $sender));
+
+    $response = $this->actingAs($user)->get(route('dashboard'));
+
+    $response->assertOk();
+    $response->assertInertia(fn (AssertableInertia $page) => $page
+        ->has('userNotifications')
+        ->where('userNotifications.unread_count', 2)
+        ->has('userNotifications.readUrl')
+        ->has('userNotifications.readAllUrl')
+        ->has('userNotifications.notificationsUrl')
+    );
+});
+
+// ── AC #1: Clicking notification marks as read ───────────
+
+test('clicking notification marks it as read via POST to notifications.read', function () {
+    [$user, $workspace, $declaration] = setupNotificationCenterTest();
+    $sender = User::factory()->create();
+
+    $user->notify(new NudgeNotification($declaration, $sender));
+    $notification = $user->notifications()->first();
+    expect($notification->read_at)->toBeNull();
+
+    $response = $this->actingAs($user)->post(route('notifications.read', $notification->id));
+
+    $response->assertRedirect();
+    $notification->refresh();
+    expect($notification->read_at)->not->toBeNull();
+});
+
+// ── AC #1: Mark all as read ──────────────────────────────
+
+test('mark all as read clears unread count for current workspace', function () {
+    [$user, $workspace, $declaration] = setupNotificationCenterTest();
+    $sender = User::factory()->create();
+
+    $user->notify(new NudgeNotification($declaration, $sender));
+    $user->notify(new DocumentUploadedNotification($declaration, 1));
+
+    expect($user->unreadNotifications()->count())->toBe(2);
+
+    $response = $this->actingAs($user)->post(route('notifications.readAll'));
+
+    $response->assertRedirect();
+    $user->refresh();
+    expect($user->unreadNotifications()->count())->toBe(0);
+});
+
+// ── AC #2: Full page renders with workspace-scoped notifications ──
+
+test('notifications page renders with workspace-scoped notifications', function () {
+    [$user, $workspace, $declaration] = setupNotificationCenterTest();
+    $sender = User::factory()->create();
+
+    $user->notify(new NudgeNotification($declaration, $sender));
+
+    $response = $this->actingAs($user)->get(route('notifications.index'));
+
+    $response->assertOk();
+    $response->assertInertia(fn (AssertableInertia $page) => $page
+        ->component('notifications/Index')
+        ->has('notifications.data', 1)
+        ->has('markAllReadUrl')
+        ->has('readUrl')
+    );
+});
+
+// ── AC #2: Pagination at 25 per page ─────────────────────
+
+test('notifications page pagination works at 25 per page', function () {
+    [$user, $workspace, $declaration] = setupNotificationCenterTest();
+
+    for ($i = 0; $i < 30; $i++) {
+        $user->notify(new DocumentUploadedNotification($declaration, 1));
+    }
+
+    $response = $this->actingAs($user)->get(route('notifications.index'));
+
+    $response->assertOk();
+    $response->assertInertia(fn (AssertableInertia $page) => $page
+        ->component('notifications/Index')
+        ->has('notifications.data', 25)
+        ->where('notifications.last_page', 2)
+    );
+});
+
+// ── AC #3: Empty state renders when no notifications ─────
+
+test('empty state renders when no notifications exist', function () {
+    [$user, $workspace, $declaration] = setupNotificationCenterTest();
+
+    $response = $this->actingAs($user)->get(route('notifications.index'));
+
+    $response->assertOk();
+    $response->assertInertia(fn (AssertableInertia $page) => $page
+        ->component('notifications/Index')
+        ->has('notifications.data', 0)
+    );
+});
+
+// ── AC #2: Cross-workspace isolation ─────────────────────
+
+test('notifications are scoped to current workspace and do not leak across workspaces', function () {
+    [$user, $workspace1, $declaration1] = setupNotificationCenterTest();
+
+    $workspace2 = Workspace::factory()->create();
+    $workspace2->users()->attach($user->id, ['role' => 'owner', 'permissions' => []]);
+    $declaration2 = Declaration::factory()->forWorkspace($workspace2)->create();
+
+    // Notify for both workspaces
+    $user->notify(new DocumentUploadedNotification($declaration1, 1));
+    $user->notify(new DocumentUploadedNotification($declaration2, 1));
+
+    // Session is set to workspace1
+    $response = $this->actingAs($user)->get(route('notifications.index'));
+
+    $response->assertOk();
+    $response->assertInertia(fn (AssertableInertia $page) => $page
+        ->component('notifications/Index')
+        ->has('notifications.data', 1)
+        ->where('notifications.data.0.data.workspace_id', $workspace1->id)
+    );
+});