@vc-shell/vc-app-skill 2.1.0 → 2.2.0-pr260.a8bd3a7

package/runtime/knowledge/docs/core/directives/loading/loading.docs.md

@@ -25,7 +25,7 @@ Unlike a standalone loading component, `v-loading` scopes the overlay to the ele
 | ----------------------- | ---------------- | ------------------------------------ |
 | `v-loading="true"`      | `boolean`        | Show/hide the loading overlay        |
 | `v-loading="options"`   | `LoadingOptions` | Show with configuration (see below)  |
-| `v-loading:1000="true"` | `arg: string`    | Set custom z-index (default: `9999`) |
+| `v-loading:1000="true"` | `arg: string`    | Set custom z-index (default: `9000`) |
 
 ### LoadingOptions
 
@@ -108,7 +108,7 @@ async function loadOrder() {
   <!-- Use a lower z-index so popups can render above the spinner -->
   <div v-loading:500="isLoading">Content</div>
 
-  <!-- Default z-index is 9999 -->
+  <!-- Default z-index is 9000 -->
   <div v-loading="isLoading">Content</div>
 </template>
 ```

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

@@ -180,5 +180,4 @@ If you call the composable from a manually managed `effectScope()`, the cleanup
 - [useNotificationStore](./useNotificationStore.md) — direct store access for app-shell features (dropdown, badge).
 - [useNotificationContext](./useNotificationContext.md) — read the current notification inside a custom template.
 - [useBroadcastFilter](./useBroadcastFilter.md) — control which `SendSystemEvents` broadcasts reach the store.
-- [Notifications concept page.](../../concepts/notifications.md)
-- [Notifications plugin reference.](../../plugins/notifications.md)
+- [Notifications overview.](../notifications.md)

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

@@ -13,7 +13,7 @@ This is the standard mechanism for scoping a multi-tenant app — show a seller
 ## When to use
 
 - Multi-tenant apps where the same broadcast topic carries events for different tenants (sellers, organizations, departments) and each user should only see their slice.
-- Apps that want to drop noisy `IndexProgressPushNotification` or similar maintenance events for non-admin roles.
+- Apps that want to drop noisy maintenance broadcasts for non-admin roles. (Note: `IndexProgressPushNotification` is already globally dropped via `EXCLUDED_NOTIFICATION_TYPES` and needs no filter.)
 - When NOT to use: filtering targeted notifications. The platform already delivers `Send` messages only to the addressed user; `useBroadcastFilter` does not see them.
 
 ## Quick Start
@@ -92,7 +92,7 @@ If the app supports user switching without a full reload (impersonation, multi-a
 ### Drop a noisy type entirely
 
 ```ts
-setBroadcastFilter((msg) => msg.notifyType !== "IndexProgressPushNotification");
+setBroadcastFilter((msg) => msg.notifyType !== "BulkActionPushNotification");
 ```
 
 Broadcast-only suppression. To suppress targeted messages too, set `toast: false` or `toast: { mode: "silent" }` on the type's `defineAppModule({ notifications })` config — that controls the toast surface; the history still records the event.
@@ -107,7 +107,7 @@ Broadcast-only suppression. To suppress targeted messages too, set `toast: false
 ## Tips
 
 - **Install once, early.** Setting the filter in `App.vue` `onMounted` (after authentication) is the canonical placement, so messages arriving before the first blade mounts are already scoped.
-- **Filter exceptions go straight to the console.** If your predicate throws, the message is dropped. Wrap the logic if you are reading off potentially missing fields.
+- **A throwing predicate is not caught.** `ingest` calls the filter without a try/catch, so an exception propagates up through ingestion — it is not logged and the message is not silently dropped. Guard field access inside the predicate (e.g. optional chaining) when reading potentially missing fields.
 - **Do not query the store from inside the filter.** The store is `useBroadcastFilter`'s parent — calling back into it during ingestion causes re-entrancy.
 
 ## Related

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

@@ -34,22 +34,22 @@ await store.loadHistory(50);
 
 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 (server-loaded plus ingested), newest first.                                                                                                                  |
-| `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. Mirrors to the server.                                                                                                                           |
-| `markAllAsRead()`        | `() => Promise<void>`                                  | Optimistic mark-all with rollback on failure.                                                                                                                              |
-| `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`.                                                                                                                                          |
+| 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
 
@@ -100,9 +100,10 @@ The fallback exists so module-federation remotes and standalone scripts see the
 
 - **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, then merges.** Calling it again pages in more entries and merges them with the existing history.
-- **`markAllAsRead` is optimistic.** The local state flips immediately; if the server call fails the change is rolled back and an error toast surfaces.
+- **`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
 

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