@quazardous/qdadm 2.27.0 → 2.29.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quazardous/qdadm",
-  "version": "2.27.0",
+  "version": "2.29.0",
   "description": "Vue 3 framework for admin dashboards with PrimeVue",
   "author": "quazardous",
   "license": "MIT",

package/src/components/show/ShowPage.vue

@@ -36,7 +36,8 @@
  * - #footer: Custom footer (replaces ShowActions if provided)
  * - #error: Custom error display
  * - #loading: Custom display for the first load. A reload of a record already
- *   on screen keeps it there, marked busy (#2435).
+ *   on screen keeps it there, marked busy (#2435); the notification badge shows
+ *   the activity (#2677).
  */
 import { computed, type PropType } from 'vue'
 import PageHeader from '../layout/PageHeader.vue'
@@ -227,7 +228,6 @@ type ShowFieldValue = string | number | boolean | Date | Record<string, unknown>
 
     <!-- Content -->
     <template v-else>
-      <div v-if="loading" class="show-refreshing" role="progressbar" aria-label="Refreshing" />
       <!-- Single content body; Card wrapper is conditional (#1193) -->
       <CardShell :card="cardWrapper">
         <!-- Grid layout with optional media zone -->
@@ -310,28 +310,7 @@ type ShowFieldValue = string | number | boolean | Date | Record<string, unknown>
   padding: 3rem;
 }
 
-/* A record being refreshed stays on screen: a thin bar says so (#2435). */
-.show-refreshing {
-  height: 3px;
-  margin-bottom: -1rem; /* inside the page gap: the content does not move */
-  background: linear-gradient(90deg, transparent, var(--p-primary-color, #3b82f6), transparent);
-  background-size: 40% 100%;
-  background-repeat: no-repeat;
-  animation: show-refreshing 1.1s ease-in-out infinite;
-}
-
-@keyframes show-refreshing {
-  from { background-position: -40% 0; }
-  to { background-position: 140% 0; }
-}
 
-@media (prefers-reduced-motion: reduce) {
-  .show-refreshing {
-    animation: none;
-    background: var(--p-primary-color, #3b82f6);
-    opacity: 0.4;
-  }
-}
 
 .show-error-message {
   margin: 1rem 0;

package/src/composables/useEntityItemFormPage.ts

@@ -37,6 +37,7 @@ import {
 } from './useEntityItemPage'
 import { registerGuardDialog, unregisterGuardDialog } from './useGuardStore'
 import { registerPageState } from './usePageState'
+import { useNotifications } from '../notifications/NotificationStore'
 import { deepClone } from '../utils/transformers'
 import { getSiblingRoutes } from '../module/moduleRegistry'
 import {
@@ -130,6 +131,8 @@ export function useEntityItemFormPage<T extends Record<string, unknown> = Record
   const route = useRoute()
   const confirm = useConfirm() as ConfirmService
   const debug = inject<boolean>('qdadmDebug', false)
+  // Loads show as activity on the notification badge (#2677); a no-op without notifications.
+  const notifications = useNotifications()
 
   // Use useEntityItemPage for common infrastructure
   const itemPage = useEntityItemPage({
@@ -291,7 +294,7 @@ export function useEntityItemFormPage<T extends Record<string, unknown> = Record
     try {
       // The item itself, never a cached list row: a list row may be a summary,
       // and whatever this form shows empty it saves back empty (#2484).
-      const responseData = await manager.get(entityId.value!, undefined, { listCache: false })
+      const responseData = await notifications.track(manager.get(entityId.value!, undefined, { listCache: false }))
       if (!isLatest()) return
       const transformed = transformLoad(responseData)
       if (debug) reportMissingFields(transformed as Record<string, unknown>)

package/src/composables/useEntityItemPage.ts

@@ -15,6 +15,7 @@
 import { ref, computed, onMounted, provide, type Ref, type ComputedRef } from 'vue'
 import { useRoute } from 'vue-router'
 import { useStackHydrator, type StackHydratorReturn } from '../chain/useStackHydrator'
+import { useNotifications } from '../notifications/NotificationStore'
 import type { EntityManagerCrud } from '../entity/EntityManager.interface'
 import type { OrchestratorLike } from '../entity/EntityManager.interface'
 import { useOrchestrator } from '../orchestrator/useOrchestrator.js'
@@ -161,6 +162,8 @@ export function useEntityItemPage<T = unknown>(config: UseEntityItemPageOptions<
 
   // Stack hydrator for setting entity data on navigation context
   const hydrator = useStackHydrator()
+  // Loads show as activity on the notification badge (#2677); a no-op without notifications.
+  const notifications = useNotifications()
 
   // ============ STATE ============
 
@@ -333,7 +336,7 @@ export function useEntityItemPage<T = unknown>(config: UseEntityItemPageOptions<
     error.value = null
 
     try {
-      const responseData = await manager.get(id)
+      const responseData = await notifications.track(manager.get(id))
       if (!isLatest()) return null
 
       if (!responseData) {

package/src/composables/useEntityItemShowPage.ts

@@ -35,7 +35,8 @@
  */
 import { ref, computed, onUnmounted, type Ref, type ComputedRef } from 'vue'
 import { registerPageState } from './usePageState'
-import { useRouter, type Router } from 'vue-router'
+import { useRouter, useRoute, type Router } from 'vue-router'
+import { useNotifications } from '../notifications/NotificationStore'
 import { useConfirm } from 'primevue/useconfirm'
 import { requireDeleteConfirmation } from './confirmDelete'
 import {
@@ -325,9 +326,26 @@ export function useEntityItemShowPage<T = Record<string, unknown>>(
   // Reload when THIS record changed outside the session (#1888 lot D).
   // Scoped by id: an event about another record must not reload every open
   // detail page. An event carrying no id concerns the whole entity and applies.
+  const notifications = useNotifications()
+  const route = useRoute()
   useLiveEntity(entity, manager, async () => {
-    await base.reload()
-  }, { id: () => entityId.value })
+    const record = await base.reload()
+    // A change made elsewhere to the record on screen leaves a line in the
+    // history (#2677): short-lived, linked back to it, never a pop-up.
+    if (!record) return
+    const name = entityLabel.value ? `"${entityLabel.value}"` : `#${entityId.value}`
+    notifications.addNotification({
+      severity: 'info',
+      summary: `${manager.label ?? entity} ${name} updated elsewhere`,
+      keep: 'short',
+      ...(route?.name ? { to: { name: String(route.name), params: { ...route.params } } } : {}),
+    })
+  }, {
+    id: () => entityId.value,
+    // The update has arrived: say so on the badge at once — before the reload is
+    // coalesced, let alone finished (#2679).
+    onEvent: () => notifications.flash(),
+  })
   // Cast orchestrator to include toast methods
   const orchestrator = baseOrchestrator as Orchestrator
 

package/src/composables/useListPage.ts

@@ -38,6 +38,7 @@ import {
 import { useConfirm } from 'primevue/useconfirm'
 import { requireDeleteConfirmation } from './confirmDelete'
 import { registerPageState, activeFilters } from './usePageState'
+import { useNotifications } from '../notifications/NotificationStore'
 import { useHooks } from './useHooks.js'
 import { useEntityItemPage, type ParentConfig, type UseEntityItemPageReturn } from './useEntityItemPage.js'
 import { useActiveStack } from '../chain/useActiveStack.js'
@@ -142,6 +143,8 @@ export function useListPage<T = unknown>(config: UseListPageOptions<T>): UseList
 
   const router = useRouter()
   const route = useRoute()
+  // Loads show as activity on the notification badge (#2677); a no-op without notifications.
+  const notifications = useNotifications()
   const confirm = useConfirm() as ConfirmService
 
   // Mobile detection (viewport width < 768px)
@@ -841,9 +844,12 @@ export function useListPage<T = unknown>(config: UseListPageOptions<T>): UseList
         params = onBeforeLoad(params) || params
       }
 
-      const response = manager.query
-        ? await manager.query(params, { routingContext: entityContext.value })
-        : await manager.list(params, entityContext.value)
+      // The request shows as activity on the notification badge (#2677).
+      const response = await notifications.track(
+        manager.query
+          ? manager.query(params, { routingContext: entityContext.value })
+          : manager.list(params, entityContext.value)
+      )
 
       fromCache.value = response.fromCache || false
 

package/src/composables/useLiveEntity.ts

@@ -27,6 +27,12 @@ export interface UseLiveEntityOptions {
    * own id: without it, changing one record reloads every open detail page.
    */
   id?: () => string | number | null | undefined
+  /**
+   * Called at once for every event that concerns this screen, before the
+   * reload is coalesced (#2679) — for a cue that must not wait, like the
+   * notification badge's flash.
+   */
+  onEvent?: () => void
 }
 
 interface LivePolicy {
@@ -129,6 +135,8 @@ export function useLiveEntity(
       }
     }
 
+    options.onEvent?.()
+
     // Coalesce: a backend replaying fifty rows must cost one reload, not fifty.
     if (coalesceMs <= 0) {
       fire()

package/src/kernel/Kernel.types.ts

@@ -199,6 +199,10 @@ export interface DebugBarConfig {
 export interface NotificationsConfig {
   enabled?: boolean
   maxNotifications?: number
+  /** Keep level per severity (#2677). Default: success and info `short`, warn and error `long`. */
+  keep?: Partial<Record<'success' | 'info' | 'warn' | 'error', 'none' | 'short' | 'long'>>
+  /** How long a `short` entry stays in the list, in ms. Default 5 minutes. */
+  shortKeepMs?: number
 }
 
 /**

package/src/kernel/Kernel.vue.ts

@@ -359,6 +359,8 @@ export function applyVueMethods(KernelClass: { prototype: Kernel }): void {
     if (this.options.notifications?.enabled) {
       this.notificationStore = createNotificationStore({
         maxNotifications: this.options.notifications.maxNotifications,
+        keep: this.options.notifications.keep,
+        shortKeepMs: this.options.notifications.shortKeepMs,
       })
       app.provide(NOTIFICATION_KEY, this.notificationStore)
     }

package/src/notifications/NotificationBadge.vue

@@ -2,23 +2,37 @@
 /**
  * NotificationBadge - Clickable overlay for the sidebar footer logo
  *
- * Always rendered as a transparent click zone over the logo.
- * When there are alerts, the parent layout applies an opacity blink
- * on the logo wrapper via :has(.notification-badge-zone--alert).
+ * Always rendered as a transparent click zone over the logo. It says three
+ * things (#2677):
+ * - something needs attention: the parent layout blinks the logo via
+ *   :has(.notification-badge-zone--alert);
+ * - how many entries are unread: a count;
+ * - work is in progress: a ring, once tracked work has lasted `activityDelayMs`;
+ * - something just arrived: a short flash, immediately (#2679).
  *
  * Click toggles the notification panel open/close.
  */
+import { computed } from 'vue'
 import { useNotifications } from './NotificationStore'
 
 const store = useNotifications()
+
+const unread = computed(() => store.unreadCount.value)
+const unreadLabel = computed(() => (unread.value > 99 ? '99+' : String(unread.value)))
 </script>
 
 <template>
   <div
     class="notification-badge-zone"
-    :class="{ 'notification-badge-zone--alert': store.hasAlert.value || store.unreadCount.value > 0 }"
+    :class="{ 'notification-badge-zone--alert': store.hasAlert.value || unread > 0 }"
+    role="button"
+    :aria-label="unread > 0 ? `Notifications, ${unread} unread` : 'Notifications'"
     @click.stop.prevent="store.toggle()"
-  />
+  >
+    <span v-if="store.isBusy.value" class="notification-badge-ring" role="progressbar" aria-label="Loading" />
+    <span v-if="store.isFlashing.value" class="notification-badge-flash" aria-hidden="true" />
+    <span v-if="unread > 0" class="notification-badge-count">{{ unreadLabel }}</span>
+  </div>
 </template>
 
 <style scoped>
@@ -32,4 +46,64 @@ const store = useNotifications()
   cursor: pointer;
   z-index: 1;
 }
+
+.notification-badge-count {
+  position: absolute;
+  top: -0.35rem;
+  right: -0.35rem;
+  min-width: 1.1rem;
+  height: 1.1rem;
+  padding: 0 0.3rem;
+  border-radius: 999px;
+  background: var(--p-primary-color, #3b82f6);
+  color: var(--p-primary-contrast-color, #fff);
+  font-size: 0.65rem;
+  font-weight: 600;
+  line-height: 1.1rem;
+  text-align: center;
+  pointer-events: none;
+}
+
+/* Work in progress: a ring around the logo. */
+.notification-badge-ring {
+  position: absolute;
+  inset: -0.25rem;
+  border-radius: 50%;
+  border: 2px solid transparent;
+  border-top-color: var(--p-primary-color, #3b82f6);
+  border-right-color: var(--p-primary-color, #3b82f6);
+  animation: notification-badge-spin 0.9s linear infinite;
+  pointer-events: none;
+}
+
+@keyframes notification-badge-spin {
+  to { transform: rotate(360deg); }
+}
+
+/* Something just arrived: a halo that grows out of the logo and fades. */
+.notification-badge-flash {
+  position: absolute;
+  inset: 0;
+  border-radius: 50%;
+  pointer-events: none;
+  animation: notification-badge-flash 0.9s ease-out 1;
+}
+
+@keyframes notification-badge-flash {
+  0% { box-shadow: 0 0 0 0 color-mix(in srgb, var(--p-primary-color, #3b82f6) 70%, transparent); }
+  100% { box-shadow: 0 0 0 14px color-mix(in srgb, var(--p-primary-color, #3b82f6) 0%, transparent); }
+}
+
+@media (prefers-reduced-motion: reduce) {
+  .notification-badge-ring {
+    animation: none;
+    border-color: var(--p-primary-color, #3b82f6);
+    opacity: 0.5;
+  }
+
+  .notification-badge-flash {
+    animation: none;
+    box-shadow: 0 0 0 3px var(--p-primary-color, #3b82f6);
+  }
+}
 </style>

package/src/notifications/NotificationModule.ts

@@ -2,14 +2,13 @@
  * NotificationModule - Optional notification panel system
  *
  * When loaded, this module:
- * - Replaces the default ToastListener with NotificationListener
- *   (captures toasts to notification store instead of ephemeral PrimeVue toasts)
  * - Registers NotificationBadge for the sidebar footer logo overlay
  * - Registers NotificationPanel zone for the panel component
  *
- * Without this module, classic toast behavior is unchanged (ToastBridgeModule).
- * With this module, toasts are captured. Use `forceToast: true` in signal data
- * to also show a classic PrimeVue toast.
+ * Toasts keep showing as pop-ups; the kernel's ToastListener also records each
+ * one in the store, for as long as its keep level says (#2677). This module used
+ * to swap the listener inside the `_app:toasts` zone, which nothing renders — so
+ * no toast was ever recorded. See docs/notifications.md.
  *
  * @example
  * // In kernel config
@@ -20,8 +19,6 @@
 
 import { Module } from '../kernel/Module'
 import type { KernelContext } from '../kernel/KernelContext'
-import { TOAST_ZONE } from '../toast/ToastBridgeModule'
-import NotificationListener from './NotificationListener.vue'
 import NotificationBadge from './NotificationBadge.vue'
 import NotificationPanel from './NotificationPanel.vue'
 
@@ -45,18 +42,6 @@ export class NotificationModule extends Module {
     ctx.zone(NOTIFICATION_BADGE_ZONE)
     ctx.zone(NOTIFICATION_STATUS_ZONE)
 
-    // Replace the toast-listener block in the toast zone with our NotificationListener.
-    // This intercepts toast signals and captures them to the notification store.
-    // The toast zone is defined by ToastBridgeModule - we replace its listener block.
-    ctx.zone(TOAST_ZONE) // Ensure the zone exists
-    ctx.block(TOAST_ZONE, {
-      id: 'toast-listener',
-      component: NotificationListener,
-      weight: 0,
-      operation: 'replace',
-      replaces: 'toast-listener',
-    })
-
     // Register badge component for sidebar footer overlay
     ctx.block(NOTIFICATION_BADGE_ZONE, {
       id: 'notification-badge',

package/src/notifications/NotificationPanel.vue

@@ -13,11 +13,21 @@
  * - Notification list (most recent first)
  * - Empty state
  */
-import { RouterLink } from 'vue-router'
+import { RouterLink, useRouter, type RouteLocationRaw } from 'vue-router'
 import { useNotifications } from './NotificationStore'
-import type { NotificationSeverity } from './NotificationStore'
+import type { Notification, NotificationSeverity } from './NotificationStore'
 
 const store = useNotifications()
+const router = useRouter()
+
+/** An entry is read when clicked; one with a `to` also takes the user there (#2677). */
+function openNotification(notif: Notification): void {
+  store.markRead(notif.id)
+  if (!notif.to) return
+  store.close()
+  // NotificationTarget mirrors StatusItem.to: a vue-router location, typed loosely for app code.
+  void router.push(notif.to as RouteLocationRaw)
+}
 
 const severityIcons: Record<NotificationSeverity, string> = {
   success: 'pi pi-check-circle',
@@ -113,9 +123,11 @@ function formatTime(timestamp: number): string {
           class="notification-item"
           :class="{
             'notification-item--unread': !notif.read,
+            'notification-item--link': !!notif.to,
             [`notification-item--${notif.severity}`]: true,
           }"
-          @click="store.markRead(notif.id)"
+          :role="notif.to ? 'link' : undefined"
+          @click="openNotification(notif)"
         >
           <div class="notification-item-icon">
             <i :class="severityIcons[notif.severity]" />

package/src/notifications/NotificationStore.ts

@@ -34,6 +34,16 @@ const NOTIFICATION_KEY: InjectionKey<NotificationStore> = Symbol('qdadm-notifica
 
 export type NotificationSeverity = 'success' | 'info' | 'warn' | 'error'
 
+/**
+ * How long an entry stays in the list (#2677): `none` is not recorded, `short`
+ * is dropped after `shortKeepMs` (read or not), `long` stays until cleared or
+ * pushed out by the cap.
+ */
+export type NotificationKeep = 'none' | 'short' | 'long'
+
+/** Where an entry leads when clicked: a vue-router location. */
+export type NotificationTarget = { name: string; params?: Record<string, unknown>; query?: Record<string, unknown> } | string
+
 export interface Notification {
   id: string
   severity: NotificationSeverity
@@ -42,6 +52,20 @@ export interface Notification {
   emitter?: string
   timestamp: number
   read: boolean
+  keep: Exclude<NotificationKeep, 'none'>
+  /** When a `short` entry leaves the list; null for `long`. */
+  expiresAt: number | null
+  to?: NotificationTarget
+}
+
+/** What `addNotification` takes: `keep` defaults by severity, see `NotificationStoreConfig.keep`. */
+export interface NewNotification {
+  severity: NotificationSeverity
+  summary: string
+  detail?: string
+  emitter?: string
+  keep?: NotificationKeep
+  to?: NotificationTarget
 }
 
 export interface StatusItem {
@@ -56,6 +80,19 @@ export interface StatusItem {
 
 export interface NotificationStoreConfig {
   maxNotifications?: number
+  /** Keep level per severity. Default: success and info `short`, warn and error `long`. */
+  keep?: Partial<Record<NotificationSeverity, NotificationKeep>>
+  /** How long a `short` entry stays, in ms. Default 5 minutes. */
+  shortKeepMs?: number
+  /** Ongoing activity shorter than this shows nothing on the badge, in ms. Default 400. */
+  activityDelayMs?: number
+}
+
+const DEFAULT_KEEP: Record<NotificationSeverity, NotificationKeep> = {
+  success: 'short',
+  info: 'short',
+  warn: 'long',
+  error: 'long',
 }
 
 export interface NotificationStore {
@@ -63,7 +100,8 @@ export interface NotificationStore {
   notifications: ComputedRef<Notification[]>
   unreadCount: ComputedRef<number>
   hasAlert: ComputedRef<boolean>
-  addNotification(n: Omit<Notification, 'id' | 'timestamp' | 'read'>): string
+  /** Records an entry and returns its id — `''` when its keep level is `none`. */
+  addNotification(n: NewNotification): string
   markRead(id: string): void
   markAllRead(): void
   removeNotification(id: string): void
@@ -75,6 +113,20 @@ export interface NotificationStore {
   updateStatus(id: string, updates: Partial<StatusItem>): void
   removeStatus(id: string): void
 
+  // Activity (#2677)
+  /** Counts `work` as in progress until it settles, and returns it unchanged. */
+  track<T>(work: Promise<T>): Promise<T>
+  /** True once tracked work has been in progress for `activityDelayMs`. */
+  isBusy: ComputedRef<boolean>
+  /**
+   * Flash the badge: something just arrived — an update to the record on
+   * screen (#2679). Immediate, never delayed; a flash already running absorbs
+   * further calls, so a burst flashes once.
+   */
+  flash(): void
+  /** True while the badge flashes. */
+  isFlashing: ComputedRef<boolean>
+
   // Panel state
   isOpen: Ref<boolean>
   open(): void
@@ -102,6 +154,9 @@ let _idCounter = 0
  */
 export function createNotificationStore(config: NotificationStoreConfig = {}): NotificationStore {
   const maxNotifications = config.maxNotifications ?? 50
+  const keepBySeverity = { ...DEFAULT_KEEP, ...(config.keep ?? {}) }
+  const shortKeepMs = config.shortKeepMs ?? 5 * 60 * 1000
+  const activityDelayMs = config.activityDelayMs ?? 400
 
   const state = reactive<NotificationState>({
     notifications: [],
@@ -112,13 +167,46 @@ export function createNotificationStore(config: NotificationStoreConfig = {}): N
 
   // ── Notifications ──────────────────────────────────────────────────────
 
-  function addNotification(n: Omit<Notification, 'id' | 'timestamp' | 'read'>): string {
+  // A `short` entry leaves when it expires; one timer, set for the soonest.
+  let pruneTimer: ReturnType<typeof setTimeout> | null = null
+
+  function schedulePrune(): void {
+    if (pruneTimer) clearTimeout(pruneTimer)
+    pruneTimer = null
+    const soonest = state.notifications.reduce<number | null>(
+      (min, n) => (n.expiresAt !== null && (min === null || n.expiresAt < min) ? n.expiresAt : min),
+      null
+    )
+    if (soonest === null) return
+    pruneTimer = setTimeout(prune, Math.max(0, soonest - Date.now()))
+  }
+
+  function prune(): void {
+    const now = Date.now()
+    for (let i = state.notifications.length - 1; i >= 0; i--) {
+      const expiresAt = state.notifications[i]!.expiresAt
+      if (expiresAt !== null && expiresAt <= now) state.notifications.splice(i, 1)
+    }
+    schedulePrune()
+  }
+
+  function addNotification(n: NewNotification): string {
+    const keep = n.keep ?? keepBySeverity[n.severity] ?? 'long'
+    if (keep === 'none') return ''
+
     const id = `notif-${++_idCounter}-${Date.now()}`
+    const timestamp = Date.now()
     const notification: Notification = {
-      ...n,
+      severity: n.severity,
+      summary: n.summary,
+      ...(n.detail !== undefined ? { detail: n.detail } : {}),
+      ...(n.emitter !== undefined ? { emitter: n.emitter } : {}),
+      ...(n.to !== undefined ? { to: n.to } : {}),
       id,
-      timestamp: Date.now(),
+      timestamp,
       read: false,
+      keep,
+      expiresAt: keep === 'short' ? timestamp + shortKeepMs : null,
     }
 
     // Add to front (most recent first)
@@ -129,6 +217,7 @@ export function createNotificationStore(config: NotificationStoreConfig = {}): N
       state.notifications.length = maxNotifications
     }
 
+    if (notification.expiresAt !== null) schedulePrune()
     return id
   }
 
@@ -181,6 +270,46 @@ export function createNotificationStore(config: NotificationStoreConfig = {}): N
     }
   }
 
+  // ── Activity ───────────────────────────────────────────────────────────
+
+  const inFlight = ref(0)
+  const busy = ref(false)
+  let busyTimer: ReturnType<typeof setTimeout> | null = null
+
+  function track<T>(work: Promise<T>): Promise<T> {
+    inFlight.value++
+    if (inFlight.value === 1) {
+      // Only work that lasts shows: a fast reload leaves the badge alone.
+      busyTimer = setTimeout(() => {
+        busyTimer = null
+        if (inFlight.value > 0) busy.value = true
+      }, activityDelayMs)
+    }
+    const settle = (): void => {
+      inFlight.value = Math.max(0, inFlight.value - 1)
+      if (inFlight.value > 0) return
+      if (busyTimer) clearTimeout(busyTimer)
+      busyTimer = null
+      busy.value = false
+    }
+    work.then(settle, settle)
+    return work
+  }
+
+  // ── Flash ──────────────────────────────────────────────────────────────
+
+  const FLASH_MS = 900
+  const flashing = ref(false)
+
+  function flash(): void {
+    // A burst of updates flashes once: the running flash already says it.
+    if (flashing.value) return
+    flashing.value = true
+    setTimeout(() => {
+      flashing.value = false
+    }, FLASH_MS)
+  }
+
   // ── Panel state ────────────────────────────────────────────────────────
 
   function open(): void {
@@ -229,6 +358,10 @@ export function createNotificationStore(config: NotificationStoreConfig = {}): N
     registerStatus,
     updateStatus,
     removeStatus,
+    track,
+    isBusy: computed(() => busy.value),
+    flash,
+    isFlashing: computed(() => flashing.value),
     isOpen,
     open,
     close,
@@ -272,6 +405,10 @@ export function useNotifications(): NotificationStore {
       registerStatus: () => {},
       updateStatus: () => {},
       removeStatus: () => {},
+      track: (work) => work,
+      isBusy: computed(() => false),
+      flash: () => {},
+      isFlashing: computed(() => false),
       isOpen: ref(false),
       open: () => {},
       close: () => {},

package/src/notifications/index.ts

@@ -32,6 +32,9 @@ export {
   NOTIFICATION_KEY,
   type Notification,
   type NotificationSeverity,
+  type NotificationKeep,
+  type NotificationTarget,
+  type NewNotification,
   type StatusItem,
   type NotificationStore,
   type NotificationStoreConfig,

package/src/orchestrator/Orchestrator.ts

@@ -59,6 +59,10 @@ export type EntityFactory = (
 export interface ToastOptions {
   life?: number
   emitter?: string
+  /** How long the notification history keeps it (#2677); default by severity. */
+  keep?: 'none' | 'short' | 'long'
+  /** Where its history entry leads: a vue-router location. */
+  to?: { name: string; params?: Record<string, unknown>; query?: Record<string, unknown> } | string
 }
 
 /**
@@ -196,6 +200,8 @@ export class Orchestrator {
             detail,
             life: opts.life ?? defaults[severity],
             emitter: opts.emitter,
+            ...(opts.keep !== undefined ? { keep: opts.keep } : {}),
+            ...(opts.to !== undefined ? { to: opts.to } : {}),
           })
         }
       }

package/src/toast/ToastListener.vue

@@ -11,15 +11,26 @@ import { onMounted, onUnmounted, inject } from 'vue'
 import { useToast } from 'primevue/usetoast'
 import type { SignalBus } from '../kernel/SignalBus'
 import { explainMissingToast } from '../kernel/vitePluginCheck'
+import {
+  NOTIFICATION_KEY,
+  type NotificationKeep,
+  type NotificationSeverity,
+  type NotificationTarget,
+} from '../notifications/NotificationStore'
 
 interface ToastEventData {
   summary?: string
   detail?: string
   life?: number
+  emitter?: string
+  keep?: NotificationKeep
+  to?: NotificationTarget
 }
 
 const toast = explainMissingToast(useToast)
 const signals = inject<SignalBus | null>('qdadmSignals', null)
+// Provided when `notifications.enabled`: every toast also leaves a trace (#2677).
+const notifications = inject(NOTIFICATION_KEY, null)
 
 let unsubscribe: (() => void) | null = null
 
@@ -39,6 +50,15 @@ onMounted(() => {
       detail: data?.detail,
       life: data?.life ?? 3000
     })
+    // The pop-up is unchanged; the history keeps it, for as long as its keep level says.
+    notifications?.addNotification({
+      severity: severity as NotificationSeverity,
+      summary: data?.summary ?? '',
+      ...(data?.detail !== undefined ? { detail: data.detail } : {}),
+      ...(data?.emitter !== undefined ? { emitter: data.emitter } : {}),
+      ...(data?.keep !== undefined ? { keep: data.keep } : {}),
+      ...(data?.to !== undefined ? { to: data.to } : {}),
+    })
   })
 })
 

package/src/toast/useSignalToast.ts

@@ -19,6 +19,7 @@
 
 import { inject, getCurrentInstance } from 'vue'
 import type { SignalBus } from '../kernel/SignalBus'
+import type { NotificationKeep, NotificationTarget } from '../notifications/NotificationStore'
 
 /**
  * Toast severity types
@@ -33,16 +34,24 @@ export interface ToastOptions {
   summary: string
   detail?: string
   life?: number
-  /** Force classic PrimeVue toast even when NotificationModule is active */
+  /** @deprecated Toasts always pop up now (#2677); kept for compatibility, it does nothing. */
   forceToast?: boolean
+  /** How long the notification history keeps it (#2677); default by severity. */
+  keep?: NotificationKeep
+  /** Where its history entry leads: a vue-router location. */
+  to?: NotificationTarget
 }
 
 /**
  * Toast method options
  */
 export interface ToastMethodOptions {
-  /** Force classic PrimeVue toast even when NotificationModule is active */
+  /** @deprecated Toasts always pop up now (#2677); kept for compatibility, it does nothing. */
   forceToast?: boolean
+  /** How long the notification history keeps it (#2677); default by severity. */
+  keep?: NotificationKeep
+  /** Where its history entry leads: a vue-router location. */
+  to?: NotificationTarget
 }
 
 /**
@@ -90,10 +99,18 @@ export function useSignalToast(emitter?: string): SignalToastAPI {
    * @param summary - Toast title
    * @param detail - Toast detail message
    * @param life - Duration in ms (0 for sticky)
-   * @param forceToast - Force classic PrimeVue toast when NotificationModule is active
+   * @param options - keep and to, for the notification history (#2677)
    */
-  function addToast(severity: ToastSeverity, summary: string, detail?: string, life: number = 3000, forceToast?: boolean): void {
-    signals.emit(`toast:${severity}`, { summary, detail, life, emitter: resolvedEmitter, forceToast })
+  function addToast(severity: ToastSeverity, summary: string, detail?: string, life: number = 3000, options?: ToastMethodOptions): void {
+    signals.emit(`toast:${severity}`, {
+      summary,
+      detail,
+      life,
+      emitter: resolvedEmitter,
+      ...(options?.forceToast !== undefined ? { forceToast: options.forceToast } : {}),
+      ...(options?.keep !== undefined ? { keep: options.keep } : {}),
+      ...(options?.to !== undefined ? { to: options.to } : {}),
+    })
   }
 
   return {
@@ -105,7 +122,7 @@ export function useSignalToast(emitter?: string): SignalToastAPI {
      * @param options - Additional options
      */
     success(summary: string, detail?: string, life: number = 3000, options?: ToastMethodOptions): void {
-      addToast('success', summary, detail, life, options?.forceToast)
+      addToast('success', summary, detail, life, options)
     },
 
     /**
@@ -116,7 +133,7 @@ export function useSignalToast(emitter?: string): SignalToastAPI {
      * @param options - Additional options
      */
     error(summary: string, detail?: string, life: number = 5000, options?: ToastMethodOptions): void {
-      addToast('error', summary, detail, life, options?.forceToast)
+      addToast('error', summary, detail, life, options)
     },
 
     /**
@@ -127,7 +144,7 @@ export function useSignalToast(emitter?: string): SignalToastAPI {
      * @param options - Additional options
      */
     info(summary: string, detail?: string, life: number = 3000, options?: ToastMethodOptions): void {
-      addToast('info', summary, detail, life, options?.forceToast)
+      addToast('info', summary, detail, life, options)
     },
 
     /**
@@ -138,7 +155,7 @@ export function useSignalToast(emitter?: string): SignalToastAPI {
      * @param options - Additional options
      */
     warn(summary: string, detail?: string, life: number = 4000, options?: ToastMethodOptions): void {
-      addToast('warn', summary, detail, life, options?.forceToast)
+      addToast('warn', summary, detail, life, options)
     },
 
     /**
@@ -146,7 +163,7 @@ export function useSignalToast(emitter?: string): SignalToastAPI {
      * @param options - Toast options
      */
     add(options: ToastOptions): void {
-      addToast(options.severity || 'info', options.summary, options.detail, options.life, options.forceToast)
+      addToast(options.severity || 'info', options.summary, options.detail, options.life, options)
     },
   }
 }