@vc-shell/vc-app-skill 2.1.0-pr255.4dc5c0d → 2.1.0-pr256.0fe3abb

package/runtime/knowledge/docs/core/notifications/composables/useNotificationStore.docs.md

@@ -0,0 +1,114 @@
+---
+title: useNotificationStore
+category: composables
+group: notifications
+---
+
+# useNotificationStore
+
+!!! warning "Advanced — most apps do not need this"
+Reach for [useBladeNotifications](./useBladeNotifications.md), [useBroadcastFilter](./useBroadcastFilter.md), and the `notifications` option on `defineAppModule` first. The bell dropdown, unread badge, and toast pipeline are already wired by the shell. This composable is an **escape hatch** for the small set of cases where those facades do not fit.
+
+Returns the singleton store that backs the framework's notification system. Direct access exposes the full reactive state plus low-level actions: subscribing, ingesting synthetic messages, controlling the broadcast filter, paging history.
+
+## When to use
+
+There are only two cases where this composable belongs in app code:
+
+- **A test or scripted harness** that needs to push synthetic messages through the same pipeline SignalR uses, via `ingest`. Real-time production code never calls `ingest` directly.
+- **A custom shell** that replaces the framework's bell dropdown entirely — typically a module-federation host with its own chrome — and therefore needs to bind to `history`, `unreadCount`, and `markAllAsRead` outside the default surface. Apps that use the standard `VcApp` shell do not need this; the dropdown is already there.
+
+For everything else — reacting in a blade, gating broadcasts, registering types, displaying a toast — use the facades. Direct store mutations can bypass invariants the facades enforce (broadcast filter, scope-aware cleanup, type validation).
+
+## Quick Start
+
+```ts
+import { useNotificationStore } from "@vc-shell/framework";
+
+const store = useNotificationStore();
+
+await store.loadHistory(50);
+```
+
+## API
+
+The store exposes the full reactive state plus actions. The shape is summarized below; the underlying types live in `core/notifications/store.ts` and `core/notifications/types.ts`.
+
+| Member                   | Type                                                   | Description                                                                                                                                                                                   |
+| ------------------------ | ------------------------------------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `registry`               | `Map<string, NotificationTypeConfig>`                  | Notification types registered through `defineAppModule({ notifications })`.                                                                                                                   |
+| `history`                | `Ref<PushNotification[]>`                              | Full history. `loadHistory` replaces it with the server's returned order; `ingest` appends new messages in arrival order. Not sorted — sort in the consumer for newest-first display.         |
+| `realtime`               | `Ref<PushNotification[]>`                              | Session-only realtime queue from the SignalR hub. Drives `messages` in `useBladeNotifications`.                                                                                               |
+| `unreadCount`            | `ComputedRef<number>`                                  | Count of unread items in `history`. Drives the bell badge.                                                                                                                                    |
+| `hasUnread`              | `ComputedRef<boolean>`                                 | Convenience boolean over `unreadCount`.                                                                                                                                                       |
+| `registerType(t, cfg)`   | `(string, NotificationTypeConfig) => void`             | Register a type. Called by the framework when `defineAppModule({ notifications })` runs — rarely needed manually.                                                                             |
+| `ingest(msg, opts?)`     | `(PushNotification, { broadcast?: boolean }?) => void` | Push a message through the same pipeline SignalR uses. Broadcasts pass through the active broadcast filter.                                                                                   |
+| `setBroadcastFilter(fn)` | `((PushNotification) => boolean) => void`              | Install a filter for broadcast messages. Prefer [useBroadcastFilter](./useBroadcastFilter.md) — same method.                                                                                  |
+| `clearBroadcastFilter()` | `() => void`                                           | Remove the broadcast filter.                                                                                                                                                                  |
+| `markAsRead(msg)`        | `(PushNotification) => void`                           | Mark one message as read locally (flips `isNew` on the matching history and realtime entries). Local-only — no server call; server read-state is reconciled by `markAllAsRead`/`loadHistory`. |
+| `markAllAsRead()`        | `() => Promise<void>`                                  | Flips local state to read immediately and syncs to the server. Server failure is logged only (no rollback) and reconciled on the next `loadHistory`.                                          |
+| `loadHistory(take?)`     | `(number?) => Promise<void>`                           | Fetch history from the platform. Default page size is 10. The shell already calls this at bootstrap.                                                                                          |
+| `subscribe(opts)`        | `({ types, filter?, handler? }) => () => void`         | Low-level pub/sub. Returns an `unsub` function. Inside blades use [useBladeNotifications](./useBladeNotifications.md) — it wraps this and registers cleanup automatically.                    |
+| `getByType(type)`        | `(string) => PushNotification[]`                       | Filter `history` by `notifyType`.                                                                                                                                                             |
+
+## Escape-hatch patterns
+
+### Manually ingest a message (tests, scripted replay)
+
+```ts
+const store = useNotificationStore();
+
+store.ingest({
+  id: "test-1",
+  notifyType: "OrderCreatedDomainEvent",
+  title: "Test order",
+  isNew: true,
+  created: new Date().toISOString(),
+} as PushNotification);
+```
+
+The ingest pipeline runs the configured toast logic and notifies subscribers exactly like a real SignalR message would, so you can verify the end-to-end behavior of `defineAppModule({ notifications })` + `useBladeNotifications` without a live hub.
+
+`ingest` with `{ broadcast: true }` simulates `SendSystemEvents` and runs the broadcast filter; without it the message is treated as targeted and bypasses the filter.
+
+### Custom shell surface (replace the bell dropdown)
+
+When you are building a shell variant that omits the framework's bell dropdown — for example, a module-federation host that renders its own header — bind to the store directly:
+
+```ts
+import { useNotificationStore } from "@vc-shell/framework";
+import { onMounted } from "vue";
+
+const store = useNotificationStore();
+
+onMounted(() => store.loadHistory(100));
+// Use store.history, store.unreadCount, store.markAllAsRead in your own components.
+```
+
+If you are using `VcApp` (the default shell), do **not** do this — the dropdown is already mounted and binding to the same store, so a second surface duplicates what is already on screen.
+
+## Resolution
+
+`useNotificationStore()` resolves in this order:
+
+1. If called inside a Vue component's `setup` (or `app.runWithContext()`), it uses `inject(NotificationStoreKey)`.
+2. Otherwise it returns a module-level singleton created on first call.
+
+The fallback exists so module-federation remotes and standalone scripts see the same store the host app uses.
+
+## Tips
+
+- **Prefer facades.** Every time you find yourself writing `store.subscribe(...)` inside a blade, you want `useBladeNotifications`. Every time you write `store.setBroadcastFilter(...)`, you want `useBroadcastFilter`. The facades exist to keep cleanup, typing, and invariants in one place.
+- **Do not iterate `realtime` for unread counts inside a blade.** That is what `useBladeNotifications` does correctly. Touching `realtime` directly couples your component to shell internals.
+- **`loadHistory` replaces.** It overwrites `history` with the fetched page (`take` controls page size, default 10); it does not merge with or accumulate onto existing entries.
+- **`markAllAsRead` flips local state immediately.** The change is kept even if the server call fails — the failure is logged only (no rollback, no error toast) and reconciled on the next `loadHistory`.
+- **Direct store mutations can bypass invariants.** The broadcast filter only runs through `ingest({ broadcast: true })`. Pushing arrays around `history.value` directly is not supported.
+- **`createNotificationStore({ toastHandle })` is exported.** `useNotificationStore()` always builds a default store wired to the real toast controller. For tests or a custom shell, construct a store directly with `createNotificationStore({ toastHandle })` to inject a stub toast handler.
+
+## Related
+
+- [useBladeNotifications](./useBladeNotifications.md) — recommended scope-aware subscription. **Start here.**
+- [useBroadcastFilter](./useBroadcastFilter.md) — broadcast acceptance gate.
+- [useNotificationContext](./useNotificationContext.md) — payload access inside templates.
+- [Notifications concept page.](../../concepts/notifications.md)
+- [Notifications plugin reference.](../../plugins/notifications.md)

package/runtime/knowledge/docs/core/notifications/notifications.docs.md

@@ -51,22 +51,22 @@ Returns the shared `NotificationStore` singleton. Resolution order:
 
 ### `NotificationStore` Interface
 
-| Member                       | Type                                         | Description                                                          |
-| ---------------------------- | -------------------------------------------- | -------------------------------------------------------------------- |
-| `registry`                   | `Map<string, NotificationTypeConfig>`        | Registered notification type configurations                          |
-| `history`                    | `Ref<PushNotification[]>`                    | All notifications (loaded from API + ingested)                       |
-| `realtime`                   | `Ref<PushNotification[]>`                    | Session-only notifications from SignalR                              |
-| `unreadCount`                | `ComputedRef<number>`                        | Count of unread notifications in history                             |
-| `hasUnread`                  | `ComputedRef<boolean>`                       | Whether any unread notifications exist                               |
-| `registerType(type, config)` | `(string, NotificationTypeConfig) => void`   | Register a notification type with toast/template config              |
-| `ingest(message, opts?)`     | `(PushNotification, {broadcast?}?) => void`  | Process an incoming notification; broadcast messages are filtered    |
-| `setBroadcastFilter(fn)`     | `((PushNotification) => boolean) => void`    | Set filter for broadcast messages (SendSystemEvents)                 |
-| `clearBroadcastFilter()`     | `() => void`                                 | Remove the broadcast filter                                          |
-| `markAsRead(message)`        | `(PushNotification) => void`                 | Mark a single notification as read                                   |
-| `markAllAsRead()`            | `() => Promise<void>`                        | Optimistic mark-all-as-read with server sync and rollback on failure |
-| `loadHistory(take?)`         | `(number?) => Promise<void>`                 | Load notification history from the API (default: 10)                 |
-| `subscribe(opts)`            | `({types, filter?, handler?}) => () => void` | Subscribe to notification types; returns unsubscribe function        |
-| `getByType(type)`            | `(string) => PushNotification[]`             | Filter history by `notifyType`                                       |
+| Member                       | Type                                         | Description                                                                                                         |
+| ---------------------------- | -------------------------------------------- | ------------------------------------------------------------------------------------------------------------------- |
+| `registry`                   | `Map<string, NotificationTypeConfig>`        | Registered notification type configurations                                                                         |
+| `history`                    | `Ref<PushNotification[]>`                    | All notifications (loaded from API + ingested)                                                                      |
+| `realtime`                   | `Ref<PushNotification[]>`                    | Session-only notifications from SignalR                                                                             |
+| `unreadCount`                | `ComputedRef<number>`                        | Count of unread notifications in history                                                                            |
+| `hasUnread`                  | `ComputedRef<boolean>`                       | Whether any unread notifications exist                                                                              |
+| `registerType(type, config)` | `(string, NotificationTypeConfig) => void`   | Register a notification type with toast/template config                                                             |
+| `ingest(message, opts?)`     | `(PushNotification, {broadcast?}?) => void`  | Process an incoming notification; broadcast messages are filtered                                                   |
+| `setBroadcastFilter(fn)`     | `((PushNotification) => boolean) => void`    | Set filter for broadcast messages (SendSystemEvents)                                                                |
+| `clearBroadcastFilter()`     | `() => void`                                 | Remove the broadcast filter                                                                                         |
+| `markAsRead(message)`        | `(PushNotification) => void`                 | Mark a single notification as read                                                                                  |
+| `markAllAsRead()`            | `() => Promise<void>`                        | Mark-all-as-read: flips local state immediately and syncs to the server; server failure is logged only, no rollback |
+| `loadHistory(take?)`         | `(number?) => Promise<void>`                 | Load notification history from the API (default: 10)                                                                |
+| `subscribe(opts)`            | `({types, filter?, handler?}) => () => void` | Subscribe to notification types; returns unsubscribe function                                                       |
+| `getByType(type)`            | `(string) => PushNotification[]`             | Filter history by `notifyType`                                                                                      |
 
 **File:** `store.ts`
 
@@ -150,7 +150,7 @@ clearBroadcastFilter();
 
 ### Toast Controller
 
-Handles toast popup display based on `NotificationTypeConfig.toast` settings. Created internally by the store.
+Handles toast popup display based on `NotificationTypeConfig.toast` settings. Created internally by the store. `createToastController()` and `createNotificationStore(options?)` are both exported factories for custom shells and test harnesses — pass `createNotificationStore({ toastHandle })` to inject a stub toast handler.
 
 **File:** `toast-controller.ts`
 
@@ -162,20 +162,40 @@ Handles toast popup display based on `NotificationTypeConfig.toast` settings. Cr
 | `"progress"` | Persistent toast updated on each message; auto-completes when `isComplete()` returns `true` |
 | `"silent"`   | No toast displayed                                                                          |
 
+### Imperative `notification` API
+
+Low-level toast helper exported from `index.ts` for firing toasts directly (used by the Toast Controller for progress toasts and by framework internals). Call `notification(content, options?)` for a default toast, or use the typed helpers.
+
+**File:** `notification.ts`
+
+| Method                            | Description                                                                 |
+| --------------------------------- | --------------------------------------------------------------------------- |
+| `notification(content, opts?)`    | Show a default toast; returns the notification id                           |
+| `notification.error(...)`         | Show an error-styled toast                                                  |
+| `notification.warning(...)`       | Show a warning-styled toast                                                 |
+| `notification.success(...)`       | Show a success-styled toast                                                 |
+| `notification.update(id, opts)`   | Update an existing toast by id (used for progress toasts)                   |
+| `notification.remove(id?)`        | Dismiss one toast by id, or all if id omitted                               |
+| `notification.clearAll()`         | Dismiss all toasts                                                          |
+| `notification.setPosition(pos)`   | Set the default toast position                                              |
+| `notification.clearPosition(pos)` | Dismiss all toasts at the given position                                    |
+| `notification.debug()`            | Log active toasts and default options; returns `{ active, defaultOptions }` |
+
 ### Types
 
 **File:** `types.ts`
 
-| Type                          | Description                                                                             |
-| ----------------------------- | --------------------------------------------------------------------------------------- |
-| `Severity`                    | `"info" \| "warning" \| "error" \| "critical"`                                          |
-| `ToastConfig`                 | Toast behavior: mode, severity (static or function), timeout, isComplete, completedType |
-| `NotificationTypeConfig`      | Per-type config: optional Vue `template` component, `toast` config, `groupBy` field     |
-| `ModuleNotificationsConfig`   | Record mapping `notifyType` strings to `NotificationTypeConfig`                         |
-| `NotificationAction`          | Action button in notification UI: label, icon, handler, visibility                      |
-| `NotificationSubscription`    | Internal subscriber record: id, types, filter, handler                                  |
-| `SEVERITY_TIMEOUTS`           | Default timeouts: info=5s, warning=8s, error=persistent, critical=persistent            |
-| `EXCLUDED_NOTIFICATION_TYPES` | Types excluded from ingestion (e.g. `"IndexProgressPushNotification"`)                  |
+| Type                          | Description                                                                                                                        |
+| ----------------------------- | ---------------------------------------------------------------------------------------------------------------------------------- |
+| `Severity`                    | `"info" \| "warning" \| "error" \| "critical"`                                                                                     |
+| `ToastConfig`                 | Toast behavior: mode, severity (static or function), timeout, isComplete, completedType                                            |
+| `NotificationTypeConfig`      | Per-type config: optional Vue `template` component, `toast` config, `groupBy` field                                                |
+| `ModuleNotificationsConfig`   | Record mapping `notifyType` strings to `NotificationTypeConfig`                                                                    |
+| `NotificationAction`          | Action button in notification UI: label, icon, handler, visibility                                                                 |
+| `NotificationSubscription`    | Internal subscriber record: id, types, filter, handler                                                                             |
+| `SEVERITY_TIMEOUTS`           | Default timeouts: info=5s, warning=8s, error=persistent, critical=persistent                                                       |
+| `EXCLUDED_NOTIFICATION_TYPES` | Types excluded from ingestion (e.g. `"IndexProgressPushNotification"`)                                                             |
+| `NotificationContextKey`      | `InjectionKey<ComputedRef<PushNotification>>` — injection key `useNotificationContext()` reads to get the current template payload |
 
 ## Usage Examples
 
@@ -233,13 +253,13 @@ const store = useNotificationStore();
 await store.loadHistory(20);
 console.log(`${store.unreadCount.value} unread notifications`);
 
-await store.markAllAsRead(); // optimistic update with rollback on failure
+await store.markAllAsRead(); // flips local state immediately; server failure is logged only, no rollback
 ```
 
 ## Related
 
-- `framework/injection-keys.ts` -- `NotificationStoreKey`, `NotificationTemplatesKey`
-- `framework/shared/components/notifications/` -- Notification dropdown UI
+- `framework/injection-keys.ts` -- `NotificationStoreKey`
+- `framework/shell/components/notification-dropdown/` -- Notification dropdown UI
 - `framework/core/api/platform.ts` -- `PushNotification`, `PushNotificationClient`
 
 <!-- internal:start -->

package/runtime/knowledge/docs/core/plugins/ai-agent/ai-agent.docs.md

@@ -49,18 +49,37 @@ app.use(aiAgentPlugin, {
 
 ### `IAiAgentConfig`
 
-| Field            | Type       | Default      | Description                                |
-| ---------------- | ---------- | ------------ | ------------------------------------------ |
-| `url`            | `string`   | `""`         | Chatbot iframe URL (required)              |
-| `title`          | `string`   | `"Virto OZ"` | Panel header title                         |
-| `width`          | `number`   | `362`        | Panel width in pixels                      |
-| `expandedWidth`  | `number`   | `500`        | Panel width when expanded                  |
-| `allowedOrigins` | `string[]` | `["*"]`      | Allowed origins for postMessage validation |
+| Field            | Type       | Default      | Description                                                                                                                                               |
+| ---------------- | ---------- | ------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `url`            | `string`   | `""`         | Chatbot iframe URL (required)                                                                                                                             |
+| `title`          | `string`   | `"Virto OZ"` | Panel header title                                                                                                                                        |
+| `width`          | `number`   | `362`        | Panel width in pixels                                                                                                                                     |
+| `expandedWidth`  | `number`   | `500`        | Panel width when expanded                                                                                                                                 |
+| `allowedOrigins` | `string[]` | `[]`         | Origins accepted for **incoming** postMessage; the first entry is the target origin for **outbound** messages to the chatbot iframe. Required — see below |
+| `parentOrigin`   | `string`   | --           | Explicit parent origin for **outbound** embedded postMessage. Required in embedded mode — see below                                                       |
+
+!!! danger "Origins must be configured — secure by default"
+The bridge is locked down by default. Set both fields to explicit origins; a wildcard `"*"` or empty value is refused (the message is dropped and logged), never trusted.
+
+- **`allowedOrigins`** governs messages the shell **accepts**, and its first entry is the target origin the shell uses to **send** `INIT_CONTEXT`/`UPDATE_CONTEXT` to the chatbot iframe. With the default `[]`, all incoming postMessages are ignored and outbound iframe messages are dropped (these carry the access token, so they are never sent to `"*"`). Set it to the chatbot's origin(s), e.g. `["https://chat.example.com"]`. A `"*"` entry is rejected outright — replace it with explicit origins.
+- **`parentOrigin`** governs messages the shell **sends to the parent frame** in embedded mode (`AI_CONTEXT_UPDATE`, `AI_TOGGLE_PANEL`, etc.). These payloads can carry the access token, so with no explicit `parentOrigin` (or `"*"`) the outbound message is dropped. Set it to the exact host origin, e.g. `"https://host.example.com"`.
+
+```ts
+app.use(AiAgentPlugin, {
+  config: {
+    url: "https://chat.example.com",
+    allowedOrigins: ["https://chat.example.com"], // incoming
+    parentOrigin: "https://host.example.com", // outbound (embedded mode)
+  },
+});
+```
 
 ### Composable: `useAiAgent()`
 
 Access the AI agent service from any component within the app.
 
+Returns `UseAiAgentReturn | undefined`. When `provideAiAgentService()` has not run, `useAiAgent()` logs an error and returns `undefined`, so guard the result before destructuring (e.g. `const ai = useAiAgent(); ai?.togglePanel()`).
+
 | Return            | Type                                        | Description                                    |
 | ----------------- | ------------------------------------------- | ---------------------------------------------- |
 | `panelState`      | `Ref<"closed" \| "open" \| "expanded">`     | Current panel state                            |
@@ -123,19 +142,19 @@ useAiAgentContext({ dataRef: selectedItems });
 ### Toggling the Panel Programmatically
 
 ```typescript
-const { togglePanel, isOpen } = useAiAgent();
+const ai = useAiAgent();
 
 function onAiButtonClick() {
-  togglePanel();
+  ai?.togglePanel();
 }
 ```
 
 ### Listening for Chatbot Messages
 
 ```typescript
-const { onMessage } = useAiAgent();
+const ai = useAiAgent();
 
-onMessage((message) => {
+ai?.onMessage((message) => {
   if (message.type === "NAVIGATE_TO_APP") {
     console.log("Chatbot wants to navigate to:", message.payload);
   }

package/runtime/knowledge/docs/core/plugins/extension-points/extension-points.docs.md

@@ -582,7 +582,7 @@ function defineExtensionPoint<M = Record<string, unknown>>(name: string, options
 
 interface DefineExtensionPointReturn<M> {
   /** Sorted list of registered components (by priority, ascending) */
-  components: ComputedRef<Array<ExtensionComponent & { meta?: M }>>;
+  components: ComputedRef<Array<Omit<ExtensionComponent, "meta"> & { meta?: M }>>;
   /** True when at least one component is registered */
   hasComponents: ComputedRef<boolean>;
 }

package/runtime/knowledge/docs/core/plugins/global-error-handler/global-error-handler.docs.md

@@ -33,7 +33,6 @@ All caught errors are parsed into human-readable messages via `parseError()` and
 
 ```typescript
 // Automatic -- called by the framework during app initialization.
-import { setupGlobalErrorHandlers } from "@vc-shell/framework";
 setupGlobalErrorHandlers(app);
 ```
 
@@ -150,6 +149,6 @@ try {
 ## Related
 
 - `framework/core/utilities/error.ts` -- `parseError()` function that extracts readable messages
-- `framework/shared/components/notifications/core/notification.ts` -- `notification.error()` toast API
+- `framework/core/notifications/notification.ts` -- `notification.error()` toast API
 - `framework/core/utilities/logger.ts` -- `createLogger()` for structured console logging
-- `framework/shared/components/error-interceptor/` -- blade-level error boundary that intercepts errors before the global handler
+- `framework/shell/components/error-interceptor/` -- blade-level error boundary that intercepts errors before the global handler

package/runtime/knowledge/docs/core/plugins/modularity/modularity.docs.md

@@ -176,12 +176,12 @@ export default defineAppModule({
 
 Key differences:
 
-|                   | `createAppModule`                       | `defineAppModule`                  |
-| ----------------- | --------------------------------------- | ---------------------------------- |
-| API style         | Positional args                         | Named options object               |
-| Notifications     | `notificationTemplates` (legacy)        | `notifications` (new typed config) |
-| Global components | 4th arg registers via `app.component()` | Not supported (use provide/inject) |
-| Status            | **Deprecated** -- will be removed       | **Current** -- use this            |
+|                   | `createAppModule`                                                                   | `defineAppModule`                  |
+| ----------------- | ----------------------------------------------------------------------------------- | ---------------------------------- |
+| API style         | Positional args                                                                     | Named options object               |
+| Notifications     | `notificationTemplates` (legacy)                                                    | `notifications` (new typed config) |
+| Global components | 4th arg accepted for backward compatibility but ignored (no `app.component()` call) | Not supported (use provide/inject) |
+| Status            | **Deprecated** -- will be removed                                                   | **Current** -- use this            |
 
 Migration is a one-line change:
 
@@ -278,7 +278,7 @@ defineBlade({
     title: "ORDERS.MENU.TITLE", // i18n key or plain string
     icon: "lucide-shopping-cart", // Icon name (lucide or fas)
     priority: 1, // Lower = higher in menu
-    permissions: ["seller:orders:view"], // Optional override
+    permissions: ["seller:orders:view"], // Optional fallback (used only when the blade has no permissions)
   },
 });
 </script>
@@ -317,7 +317,7 @@ defineBlade({
 </script>
 ```
 
-Under the hood, `defineAppModule` calls `addMenuItem()` from `useMenuService` with:
+Under the hood, the BladeRegistry registration function (invoked during `defineAppModule`'s install) calls `addMenuItem()` from `useMenuService` with:
 
 ```typescript
 addMenuItem({
@@ -383,7 +383,7 @@ export default defineAppModule({
 | Field           | Type                               | Default           | Description                                                                           |
 | --------------- | ---------------------------------- | ----------------- | ------------------------------------------------------------------------------------- |
 | `mode`          | `"auto" \| "progress" \| "silent"` | required          | `auto` = show and auto-dismiss; `progress` = stay until complete; `silent` = no toast |
-| `severity`      | `Severity \| (msg) => Severity`    | `"info"`          | Toast type: `"info"`, `"success"`, `"warning"`, `"error"`                             |
+| `severity`      | `Severity \| (msg) => Severity`    | `"info"`          | Toast type: `"info"`, `"warning"`, `"error"`, `"critical"`                            |
 | `timeout`       | `number`                           | varies            | Auto-dismiss timeout in milliseconds                                                  |
 | `isComplete`    | `(msg) => boolean`                 | `msg.finished`    | For `progress` mode: when to close the toast                                          |
 | `completedType` | `(msg) => "success" \| "error"`    | `() => "success"` | For `progress` mode: final toast type                                                 |
@@ -507,7 +507,7 @@ flowchart TD
 
 Non-OK manifest responses (401 / 403 / 404 / 5xx) are treated as "no plugins" — the host logs a `console.warn`, sets `modulesReady=true`, and mounts without extensions. Only network or parse failures set `modulesLoadError=true`.
 
-See the [Module Federation guide](../guides/module-federation/index.md) for the full plugin-author + host-app walkthrough.
+See [Plugin Loading (Module Federation)](#plugin-loading-module-federation) above and the `packages/mf-host/` package for the full plugin-author + host-app walkthrough.
 
 The host shares singleton instances of core dependencies (Vue, Vue Router, vue-i18n, @vc-shell/framework) so that remote modules use the same runtime. This is critical for reactivity, routing, and DI to work across module boundaries.
 
@@ -853,12 +853,12 @@ interface DashboardWidget {
 
 **`MenuItemConfig`:**
 
-| Field         | Type       | Description                                                     |
-| ------------- | ---------- | --------------------------------------------------------------- |
-| `title`       | `string`   | Display text or i18n key                                        |
-| `icon`        | `string`   | Icon name (lucide-_ or fas fa-_)                                |
-| `priority`    | `number`   | Sort order (lower = higher in menu)                             |
-| `permissions` | `string[]` | Permission override (optional, falls back to blade permissions) |
+| Field         | Type       | Description                                                                                          |
+| ------------- | ---------- | ---------------------------------------------------------------------------------------------------- |
+| `title`       | `string`   | Display text or i18n key                                                                             |
+| `icon`        | `string`   | Icon name (lucide-_ or fas fa-_)                                                                     |
+| `priority`    | `number`   | Sort order (lower = higher in menu)                                                                  |
+| `permissions` | `string[]` | Optional fallback used only when the blade has no `permissions`; blade `permissions` take precedence |
 
 ---
 
@@ -893,13 +893,13 @@ interface ToastConfig {
 
 ## Related
 
-| Resource                | Path                                  | Description                                      |
-| ----------------------- | ------------------------------------- | ------------------------------------------------ |
-| Extension Points Plugin | `core/plugins/extension-points/`      | Cross-module UI extension system                 |
-| BladeRegistry           | `core/composables/useBladeRegistry/`  | Where blades are stored and looked up            |
-| useMenuService          | `core/composables/useMenuService/`    | `addMenuItem()` for sidebar navigation           |
-| useDashboard            | `core/composables/useDashboard/`      | Dashboard widget management                      |
-| NotificationStore       | `core/notifications/`                 | Notification type registration and dispatch      |
-| i18n Plugin             | `core/plugins/i18n/`                  | vue-i18n singleton for locale merging            |
-| mf-host                 | `packages/mf-host/`                   | Module Federation host that loads remote modules |
-| Blade Navigation        | `shared/components/blade-navigation/` | Blade stack rendering and navigation             |
+| Resource                | Path                                 | Description                                      |
+| ----------------------- | ------------------------------------ | ------------------------------------------------ |
+| Extension Points Plugin | `core/plugins/extension-points/`     | Cross-module UI extension system                 |
+| BladeRegistry           | `core/composables/useBladeRegistry/` | Where blades are stored and looked up            |
+| useMenuService          | `core/composables/useMenuService/`   | `addMenuItem()` for sidebar navigation           |
+| useDashboard            | `core/composables/useDashboard/`     | Dashboard widget management                      |
+| NotificationStore       | `core/notifications/`                | Notification type registration and dispatch      |
+| i18n Plugin             | `core/plugins/i18n/`                 | vue-i18n singleton for locale merging            |
+| mf-host                 | `packages/mf-host/`                  | Module Federation host that loads remote modules |
+| Blade Navigation        | `core/blade-navigation/`             | Blade stack logic and navigation                 |

package/runtime/knowledge/docs/core/plugins/permissions/permissions.docs.md

@@ -13,7 +13,7 @@ Permission-based access control plugin. Exposes a global `$hasAccess` helper for
 
 The VirtoCommerce platform uses a role-based permission system where each user is assigned one or more roles, and each role grants a set of named permissions (e.g., `order:read`, `order:create`, `catalog:manage`). The permissions plugin bridges this system into the Vue application layer so that UI elements can be shown or hidden based on the current user's access rights.
 
-The plugin installs the `hasAccess()` function from the `usePermissions()` composable as both a Vue global property (`$hasAccess`) and a provide/inject injectable (`"$hasAccess"`). This means permission checks are available everywhere: in templates via `$hasAccess()`, in composition API code via `usePermissions()`, and in any injecting component.
+The plugin installs the `hasAccess()` function from the `usePermissions()` composable as a Vue global property (`$hasAccess`). This means permission checks are available everywhere: in templates via `$hasAccess()` and in composition API code via `usePermissions()`.
 
 ## When to Use
 
@@ -28,14 +28,13 @@ The framework installs this plugin automatically during app setup. Module develo
 ```typescript
 // Automatic -- installed by the framework during app setup.
 // The plugin source is straightforward:
-import { usePermissions } from "@core/composables/usePermissions";
+import { usePermissions } from "@vc-shell/framework";
 import { App } from "vue";
 
 export const permissions = {
   install(app: App) {
     const { hasAccess } = usePermissions();
     app.config.globalProperties.$hasAccess = hasAccess;
-    app.provide("$hasAccess", hasAccess);
   },
 };
 ```

package/runtime/knowledge/docs/core/plugins/signalR/signalR.docs.md

@@ -21,8 +21,8 @@ The VirtoCommerce platform uses ASP.NET SignalR to push real-time notifications
 
 The SignalR plugin establishes a persistent WebSocket connection to the platform hub and listens for two event channels:
 
-- **`Send`** -- broadcast messages sent to all connected clients
-- **`SendSystemEvents`** -- messages filtered by `creator` field, scoped to a specific user or organization
+- **`Send`** -- targeted messages ingested with default routing
+- **`SendSystemEvents`** -- ingested as broadcast (`store.ingest(message, { broadcast: true })`), no creator filtering
 
 Incoming messages are ingested into the `NotificationStore`, which dispatches them to registered notification type handlers and triggers toast notifications based on per-type configuration.
 
@@ -32,38 +32,21 @@ The connection lifecycle is tied to the user's authentication state: it connects
 
 ```typescript
 // Automatic -- installed by the framework during app setup.
-// The `creator` option is typically set to the current user/organization ID.
-app.use(signalR, { creator: currentUserId });
+// The plugin takes no options.
+app.use(signalR);
 ```
 
 Module developers do not install this plugin. It is registered once by the framework during bootstrap.
 
 ## API
 
-### Plugin Options
-
-| Option    | Type                  | Description                                                                |
-| --------- | --------------------- | -------------------------------------------------------------------------- |
-| `creator` | `string \| undefined` | Filters `SendSystemEvents` messages to only those matching this creator ID |
-
 ### Exports
 
-| Export                       | Type           | Description                                   |
-| ---------------------------- | -------------- | --------------------------------------------- |
-| `signalR`                    | `Plugin`       | Vue plugin object with `install()` method     |
-| `updateSignalRCreatorSymbol` | `InjectionKey` | Injection key for the creator update function |
-
-### Provided Injectables
-
-| Key                          | Type                                     | Description                                   |
-| ---------------------------- | ---------------------------------------- | --------------------------------------------- |
-| `updateSignalRCreatorSymbol` | `(creator: string \| undefined) => void` | Updates the SignalR creator filter at runtime |
-
-### Global Properties
+| Export    | Type     | Description                               |
+| --------- | -------- | ----------------------------------------- |
+| `signalR` | `Plugin` | Vue plugin object with `install()` method |
 
-| Property                | Type                                     | Description                                                         |
-| ----------------------- | ---------------------------------------- | ------------------------------------------------------------------- |
-| `$updateSignalRCreator` | `(creator: string \| undefined) => void` | Same as the injectable, accessible via `this.$updateSignalRCreator` |
+The plugin installs with no options: `app.use(signalR)`.
 
 ## Connection Lifecycle
 
@@ -80,7 +63,7 @@ sequenceDiagram
 
     Hub-->>C: "Send" (targeted)
     C->>Store: ingest(message)
-    Hub-->>C: "SendSystemEvents" (broadcast, filtered by creator)
+    Hub-->>C: "SendSystemEvents" (broadcast)
     C->>Store: ingest(message, { broadcast: true })
 
     Store->>Store: toast • subscriber callbacks • history update
@@ -98,24 +81,6 @@ sequenceDiagram
 
 ## Usage
 
-### Updating the Creator Filter
-
-After login or when switching organizations, update the creator to scope system events:
-
-```typescript
-import { inject } from "vue";
-import { updateSignalRCreatorSymbol } from "@vc-shell/framework";
-
-const updateCreator = inject(updateSignalRCreatorSymbol);
-updateCreator?.(currentUser.id);
-```
-
-Or via the global property in Options API (legacy):
-
-```typescript
-this.$updateSignalRCreator(currentUser.id);
-```
-
 ### How Messages Flow
 
 1. Platform sends a `PushNotification` via SignalR
@@ -156,13 +121,9 @@ cy.signalR("pushNotificationHub").invoke("Send", {
 });
 ```
 
-## Tip: Creator vs. Broadcast
-
-If your notification type should reach all connected clients regardless of who triggered it, use the `Send` channel (the platform sends it as a broadcast). For user-scoped notifications (e.g., "your export is complete"), use `SendSystemEvents` with the `creator` field set to the user's ID on the server side.
-
-## Common Mistake
+## Tip: Send vs. SendSystemEvents
 
-Do not call `updateCreator` before the SignalR connection is established. The plugin watches the `currentCreator` ref and re-registers the `SendSystemEvents` handler only when the connection state is `"Connected"`. If you set the creator before authentication, it will be applied when the connection starts.
+Both channels ingest into the same `NotificationStore`. `Send` messages are ingested with default routing; `SendSystemEvents` messages are ingested as broadcast (`{ broadcast: true }`). The plugin does not filter either channel by a creator field -- any scoping to a specific user or organization must happen server-side before the message is pushed.
 
 ## Related