portal-mojo 0.1.0 → 0.2.0

package/docs/personas.md

@@ -0,0 +1,212 @@
+# personas — hats/roles a signed-in user operates under (presentation only)
+
+```ts
+import {
+    definePersonas, getPersonas, getPersona, availablePersonas, personaHome,
+    PersonaProvider, usePersona, usePersonaFollowsRoute,
+    personaSectionRoutes, personaSectionsMenu, personasOwningPath,
+    personaPresets, registerPersonaMemberPermissions,
+    auditPersonas,
+    type PersonaDef, type PersonaSection, type PersonaSectionChild,
+    type PersonaSectionOwnership, type PersonaPreset, type PersonaContextValue,
+} from 'portal-mojo/personas';
+import { readPersisted, writePersisted, clearPersisted } from 'portal-mojo/client';
+```
+
+A **persona** is a working identity the user operates the portal AS — a
+support agent, a brand owner, a compliance officer. Switching persona
+reshapes the sidebar, the shell density, and "home". It changes NOTHING about
+what the user may do.
+
+## The one invariant that matters
+
+**A persona is presentation ONLY. `<Guarded>` / `hasPermission` are the
+security boundary.** `hasPermission` has no persona input by design (the
+verify script greps for this); `sys.*` stays system-pinned and untouched.
+The worst an over-optimistic persona can produce is an empty shell — every
+menu item still permission-filters fail-closed, every route is still Guarded.
+
+## Hats vs roles
+
+- **Hat** — `gate` absent: available to every authenticated user. A pure
+  view preference ("show me the ops layout").
+- **Role** — `gate` (any-of `PermSpec`): the persona appears only for users
+  holding one of its gate keys. Gate on **signature keys** — keys held by
+  exactly ONE preset. Gating on shared capability keys leaks portals
+  (`players.view` means "may read player records", not "is a support agent" —
+  the wmx 2026-08-09 audit found exactly this class). `auditPersonas`
+  mechanizes the check; strictness is opt-in.
+
+## Declaring personas
+
+```ts
+// boot.ts — categories FIRST, then personas that reference them by name
+registerPermissionCategories({ support: ['support.queue', 'support.moderation'] });
+definePersonas([
+    { slug: 'support', label: 'Support', icon: 'bi-headset', home: '/support',
+      density: 'simple', gate: ['support.queue'],
+      grants: { categories: ['support'], keys: ['players.view'] } },
+    { slug: 'explorer', label: 'Explorer', home: '/' }, // a hat: no gate, no grants
+]);
+```
+
+`definePersonas` REPLACES the registry (declare once at boot; HMR re-runs are
+safe). Duplicate slugs are ignored WITH a console.warn — first wins.
+`availablePersonas(me)`: `null` me → `[]`; hats always included for an
+authenticated user; roles via `hasPermission(me, gate)` (user-level — member
+context is not consulted).
+
+## PersonaProvider — the single owner
+
+```tsx
+<PersonaProvider fallback="support">
+    <AppShell />
+</PersonaProvider>
+```
+
+Owns the active persona and fans it out to:
+
+1. **React context** — `usePersona()` → `{ persona, def, personas, available,
+   setPersona }` (throws outside the provider).
+2. **The menu-resolution signal** (`ui/active-persona.ts`) — how
+   `resolveActiveMenu`/`SidebarNav` receive the persona without importing this
+   module.
+3. **Root attributes** — `<html data-persona="support" data-density="simple">`
+   for persona-scoped styling. Unmount clears both signal and attributes.
+
+Lifecycle: initial = valid persisted slug (`mojo:persona` via
+`readPersisted`, validated against defined slugs — garbage is cleared, never
+cast) → else a valid `fallback` prop → else the first defined persona. Once
+`me` resolves and at least one persona is available, a persona the user
+doesn't hold **snaps** to `available[0]` (state-only; the stored choice
+survives for when grants return). Zero-available keeps the current defined
+persona — safe because menus/routes stay fail-closed.
+
+### Root styling law
+
+Persona-scoped CSS variables MUST carry `:root` defaults:
+
+```css
+:root { --queue-accent: var(--accent); }        /* the default is mandatory */
+:root[data-persona='support'] { --queue-accent: var(--good); }
+```
+
+Cautionary example (wmx): a variable defined ONLY under
+`[data-wmx-view='support']` rendered as the literal fallback off-lens — every
+surface styled per-persona was broken for every other persona. Pre-auth the
+attribute may also briefly be absent entirely. Default at `:root`, override
+under `data-persona`. Same for `data-density` (`'simple' | 'dense'`; the
+provider stamps `dense` when a persona doesn't say).
+
+## Menus: persona is a resolution INPUT
+
+`MenuConfig.personas?: string[]` scopes a menu to persona slugs. Menus are
+**declared ONCE** at import/boot via `registerMenus` — never re-registered to
+switch personas (that was wmx's `applyViewMenu` mutation; the primitive
+replaces it). Resolution (`ui/menu-registry.ts`):
+
+1. First registered **eligible** menu whose visible items contain the route —
+   persona-scoped menus are eligible only while their persona is active, so
+   two personas may both carry `/players` and the active persona's menu wins.
+2. **2a.** The active persona's own first menu (preferring one with visible
+   items) — beats `defaultMenu`.
+3. 2b. `defaultMenu`, then the agnostic fallback chain.
+
+Apps that never touch personas are unaffected: the signal stays `null`,
+persona-scoped menus are simply never eligible, agnostic menus resolve
+exactly as before.
+
+## PersonaSection — routes + sidebar from one declaration
+
+```tsx
+const SECTIONS: PersonaSection[] = [{
+    id: 'wmx:support', label: 'Support Console', icon: 'bi-headset',
+    basePath: 'support', permissions: ['players.view', 'support.queue'],
+    groupScoped: true,
+    personas: { support: {}, owner: { label: 'Support (read)', navGroup: 'Oversight' } },
+    element: <ConsoleHome />,
+    children: [
+        { path: 'redemptions', label: 'Redemptions', icon: 'bi-cash-coin',
+          navGroup: 'Work queues', permissions: ['redemptions.view', 'sys.admin'],
+          element: <RedemptionsQueuePage /> },
+        { path: 'player/:id', label: 'Player', hidden: true,
+          permissions: ['players.view'], element: <PlayerView /> }, // route, no nav row
+    ],
+}];
+
+const router = createHashRouter([{ element: <AppShell />, children: [
+    ...personaSectionRoutes(SECTIONS), /* … */
+]}]);
+registerMenus(personaSectionsMenu(SECTIONS)); // ONCE, at boot
+```
+
+- `personaSectionRoutes` — every element wrapped in fail-closed
+  `<Guarded permission={…} fallback={null}>`; `groupScoped` adds
+  `<RequiresGroup>` INSIDE the guard. Deliberately **not** admin/core's
+  `guardedElement`: that wraps `AdminGlobalScope`, which blanks group/member —
+  right for the framework admin, wrong for product surfaces where member
+  grants count. Hidden children still route.
+- `personaSectionsMenu` — ONE `MenuConfig` per persona slug
+  (`name: 'persona:<slug>'`, `personas: [slug]`); items are that persona's
+  sections with per-persona `label`/`navGroup`/`order` overrides applied;
+  `navGroup` renders as side-label divider rows; every item carries the
+  section/child permissions so `itemVisible` filters fail-closed.
+- `usePersonaFollowsRoute()` — call once in the shell: when navigation lands
+  on a route owned by other personas' sections and the user HOLDS an owner,
+  the persona converges to it. Never navigates. (Owners derive from the
+  sections passed to the two builders above — wire routes/menus first.)
+- `personaHome(slug)` — the persona's landing route (unknown slug → warn + `/`).
+
+## Phase B — presets as data
+
+`grants` on a persona is its preset: `keys` (granulars) plus `categories`
+(**names** of categories the app already registered via
+`registerPermissionCategories` — register categories first; an unknown name
+expands to nothing with a warn).
+
+- `personaPresets()` → `{slug, label, keys}[]` — deduped union per persona;
+  hats without `grants` are omitted.
+- `registerPersonaMemberPermissions({ tooltipBySlug? })` — feeds the union of
+  preset keys into the admin members catalog (`registerMemberPermissions`) so
+  team UIs render switches. `sys.*`/non-editable keys are dropped up front —
+  system-pinned keys can never be member grants.
+- The **"apply preset"** button (check a preset's boxes on a member form) is
+  app-side UI over this data; the server stays authoritative on every write.
+
+## auditPersonas
+
+```ts
+auditPersonas(getPersonas(), personaPresets())                          // leak report
+auditPersonas(getPersonas(), personaPresets(), { strict: 'signature-diagonal' })
+```
+
+Default findings: a persona's gate key held by ANOTHER persona's preset (that
+preset's holders see a portal that isn't theirs). Strict adds: every gate key
+held by exactly one preset, and each persona's same-slug preset satisfies its
+own gate. Hats are skipped. Run it in a boot-time dev assert or a verify
+script; `findings: []` is the pass state.
+
+## Persistence helper (`portal-mojo/client`)
+
+`readPersisted(key, validate)` / `writePersisted(key, value)` /
+`clearPersisted(key)` — the params.ts localStorage discipline for single
+values: feature-detected storage, validate-don't-cast, invalid/unparseable
+entries **cleared and null**, silent no-op writes. JSON canonical; a legacy
+bare-string value is offered to the validator raw and self-heals to JSON on
+the next write.
+
+## Pitfalls
+
+- **Menus are declared once.** Re-registering per persona reintroduces
+  mutable menu state; the persona input + `MenuConfig.personas` replaces it.
+- **Pre-auth optimism.** Before `me` resolves the stored persona is applied;
+  its menu may render with zero visible items until grants load. That is the
+  fail-closed contract working, not a bug — don't "fix" it by widening
+  `itemVisible`.
+- **localStorage is hostile.** Never `getItem(...) as Persona` — always the
+  validate-then-clear read (`readPersisted`); the provider already does this
+  for `mojo:persona`.
+- **Don't gate on shared capability keys** (role personas) — signature keys
+  only; `auditPersonas` strict mode enforces it.
+- **Don't reach for AdminSection** for persona surfaces — its guard blanks
+  the active group, so member grants stop counting.

package/docs/realtime.md

@@ -28,8 +28,50 @@ disable this shared provider.
   separately and is never explicitly subscribed by the client. That automatic
   topic is a delivery scope, not a presence feed.
 - Framework messages, one wrapped `{type:'message',data,topic?,timestamp?}`
-  layer, and direct application events share one dispatch boundary. Malformed
-  frames drop. No generic Query invalidation is performed.
+  layer, and direct application events share one dispatch boundary. Every
+  projected event carries `source: 'wrapped' | 'direct'` so consumers can keep
+  capability-bearing protocols on their exact wire source. Malformed frames
+  drop. No generic Query invalidation is performed.
+
+## Error frames
+
+A top-level `{type:'error'}` frame is attributed in order:
+
+1. **During authentication** — auth failure: the client closes and suspends
+   until the token value changes. Surfaces through the lifecycle status only;
+   no `error` event is dispatched.
+2. **While a subscribe/unsubscribe is pending** — that operation's denial
+   (acknowledgements are uncorrelated, so denial is a generic `error`); the
+   topic reports `denied`. Surfaces through the topic status only; no `error`
+   event is dispatched.
+3. **Otherwise** — a backend answer to an application frame (chat rate limit,
+   room rules, moderation block). Dispatched as an observable `error` event
+   with `source: 'direct'`.
+
+Application error frames carry the message in `error` and may carry a
+`reasons` array: `{type:'error', error:'Rate limit exceeded'}`,
+`{type:'error', error:'Message blocked by moderation', reasons:[...]}`.
+
+Known ambiguity, inherent to the uncorrelated wire: an application error
+landing while a subscribe/unsubscribe is pending is still read as that
+operation's denial.
+
+Consumer pattern — a chat composer listens for `error` alongside its ack event
+and surfaces the backend's message instead of guessing from a timeout:
+
+```tsx
+const chatError = defineRealtimeEvent('error', (value) => {
+  const frame = value as {error?: unknown; reasons?: unknown};
+  return typeof frame?.error === 'string'
+    ? {error: frame.error, reasons: Array.isArray(frame.reasons) ? frame.reasons : undefined}
+    : null;
+});
+
+useRealtimeEvent(chatError, ({data}) => showSendFailure(data.error, data.reasons));
+```
+
+The may-not-have-sent timeout heuristic remains the right fallback for the
+no-frame-at-all case — a socket drop mid-send produces no error frame at all.
 
 The transport does not invent application events. Current django-mojo has no
 canonical record-created/updated/deleted stream and no canonical presence

package/docs/route-error.md

@@ -0,0 +1,64 @@
+# RouteError — the route-level last-resort error card
+
+```ts
+import { RouteError, RouteErrorCard, describeRouteError, isChunkLoadError, isNotFoundError } from 'portal-mojo/ui';
+// also exported from 'portal-mojo/ui/shell'
+```
+
+Any error that reaches the router without this renders React Router's raw
+default — "Unexpected Application Error!" on a white page. `RouteError` is
+the styled replacement: real message + stack for `Error` throws, a
+status/body/JSON dump for object throws (rejected mojo envelopes — never
+`[object Object]`), a "Page not found" branch for 404s, and Reload +
+Back-to-home actions. Token classes only; renders correctly in both themes,
+inside the shell or standalone.
+
+## The error-handling ladder
+
+1. **`safeNode` / `RenderGuard`** (#1602) — per-site: table cells, detail
+   sections. Degrade to a marker; the page survives.
+2. **`LazyPageBoundary`** (#1557, narrowed by #1604) — **chunk-load failures
+   only** (stale deploy): the "Retry" card. Any other error is rethrown —
+   a real page crash must not be mislabeled "bundle unavailable".
+3. **Child-level `errorElement`** — a pathless wrapper around the app's
+   routes: a page crash renders the card **inside the app shell**
+   (Sidebar/TopNav stay alive).
+4. **Root-level `errorElement`** — 404s and shell crashes. By router
+   semantics it *replaces* the root element, so the card renders bare and
+   is styled to stand alone.
+
+## Wiring (the portal scaffold ships this)
+
+```tsx
+const router = createHashRouter([
+    {
+        path: '/',
+        element: <RequireAuth><App /></RequireAuth>,
+        errorElement: <RouteError />,                       // 404s + shell crashes (bare)
+        children: [
+            { errorElement: <RouteError />, children: [...adminRoutes] },  // in-shell page crashes
+        ],
+    },
+    { path: '/auth', element: <AuthLayout />, errorElement: <RouteError />, children: [/* lazy pages */] },
+]);
+```
+
+## API
+
+| Export | What |
+|---|---|
+| `RouteError({ homeTo? })` | Data-router wrapper: reads `useRouteError()`. Use as `errorElement`. |
+| `RouteErrorCard({ error, homeTo?, onReload? })` | Presentational card. Use outside data routers (`useRouteError` THROWS there — the showcase's plain `<HashRouter>` is why this split exists). `onReload` replaces the hard `window.location.reload()` on both actions (demos/tests). |
+| `describeRouteError(err)` | Total stringifier: Error → message+stack; object → status/statusText head + string body + JSON dump (circular-safe); else `String(err)`. |
+| `isNotFoundError(err)` | Structural router-ErrorResponse check with `status === 404`. |
+| `isChunkLoadError(err)` | Vite dynamic-import failure predicate. When in doubt it returns `false` — a rethrown real crash with the true message beats a wrong Retry card. |
+
+## Caveats
+
+- **Unauthenticated 404 deep links** see "Page not found" instead of the
+  login redirect: the root `errorElement` replaces `RequireAuth`. Deliberate
+  — Back-to-home re-enters through the auth guard.
+- The 404 branch suppresses the JSON dump (noise); the crash branch shows
+  everything a developer needs. The crash still logs to the console.
+- The card never itself crashes: no queries, no app context,
+  `describeRouteError` is total.

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "portal-mojo",
-    "version": "0.1.0",
+    "version": "0.2.0",
     "description": "React portal toolkit for django-mojo — typed client + params store, mission-control UI, dependency-free SVG charts, admin section bundles.",
     "type": "module",
     "license": "Apache-2.0",
@@ -26,9 +26,22 @@
     },
     "exports": {
         "./client": "./src/client/index.ts",
+        "./client/runtime": "./src/client/runtime.ts",
         "./ui": "./src/ui/index.ts",
+        "./ui/shell": "./src/ui/shell.ts",
         "./charts": "./src/charts/index.ts",
-        "./admin": "./src/admin/index.ts"
+        "./personas": "./src/personas/index.ts",
+        "./admin": "./src/admin/index.ts",
+        "./admin/core": "./src/admin/core/index.ts",
+        "./admin/registry": "./src/admin/registry.ts",
+        "./admin/identity": "./src/admin/public/identity.ts",
+        "./admin/security": "./src/admin/public/security.ts",
+        "./admin/observability": "./src/admin/public/observability.ts",
+        "./admin/operations": "./src/admin/public/operations.ts",
+        "./admin/infrastructure": "./src/admin/public/infrastructure.ts",
+        "./admin/communications": "./src/admin/public/communications.ts",
+        "./admin/assistant": "./src/admin/public/assistant.ts",
+        "./admin/assistant/launcher": "./src/admin/public/assistant-launcher.ts"
     },
     "scripts": {
         "typecheck": "tsc --noEmit"

package/src/admin/assistant/AssistantLauncher.tsx

@@ -0,0 +1,23 @@
+import { useEffect, useState, type MouseEvent } from 'react';
+import { useCan } from '../../client/runtime';
+import { useRightPanel } from '../../ui/RightPanel';
+import { ASSISTANT_PERMISSIONS } from './permissions';
+
+export function AssistantLauncher() {
+    const { can } = useCan(ASSISTANT_PERMISSIONS);
+    const panel = useRightPanel();
+    const [loading, setLoading] = useState(false);
+    const [error, setError] = useState('');
+    useEffect(() => { if (!can && panel.descriptor?.key.startsWith('assistant:')) panel.close(); }, [can, panel]);
+    if (!can) return null;
+    const open = async (event: MouseEvent<HTMLButtonElement>) => {
+        const launcher = event.currentTarget;
+        setLoading(true); setError('');
+        try {
+            const { AssistantPanel } = await import('./AssistantPanel');
+            panel.open({ key: 'assistant:new', title: 'Assistant', render: (context) => <AssistantPanel context={context} /> }, launcher);
+        } catch { setError('Assistant could not load. Click to retry.'); }
+        finally { setLoading(false); }
+    };
+    return <button type="button" className="btn-icon" title={error || 'Open Assistant'} aria-label={error || 'Open Assistant'} aria-pressed={panel.descriptor?.key === 'assistant:new'} disabled={loading} onClick={(event) => void open(event)}><i className="bi bi-stars" aria-hidden="true" /></button>;
+}

package/src/admin/assistant/AssistantPanel.tsx

@@ -1,13 +1,14 @@
 import { useEffect, useRef, useState } from 'react';
-import { useCan, useMe, useRealtime, useRealtimeStatus } from '../../client';
+import { useCan, useMe, useRealtime, useRealtimeStatus } from '../../client/runtime';
 import type { RightPanelRenderContext } from '../../ui';
 import { AssistantFeed } from './AssistantFeed';
 import { sendAssistantMessage } from './api';
 import type { AssistantConversation, AssistantMessage } from './types';
 import type { FileReference } from '../../client/record-feed';
 import { AssistantOutcomeUnknownError, chooseAssistantTransport, startAssistantRealtimeTurn, type AssistantRealtimeProgress, type AssistantRealtimeTurn } from './streaming';
+import { ASSISTANT_PERMISSIONS } from './permissions';
 
-export const ASSISTANT_PERMISSIONS = ['sys.view_admin', 'sys.assistant'];
+export { ASSISTANT_PERMISSIONS } from './permissions';
 
 export function AssistantPanel({ context, initialConversation = null }: { context: RightPanelRenderContext; initialConversation?: AssistantConversation | null }) {
     const { can } = useCan(ASSISTANT_PERMISSIONS);

package/src/admin/assistant/api.ts

@@ -1,4 +1,4 @@
-import { mojoCall, mojoDelete, mojoList, type Params } from '../../client';
+import { mojoCall, mojoDelete, mojoList, type Params } from '../../client/runtime';
 import { projectConversation, projectConversationSummary, projectReply, projectSkill } from './data';
 import type { AssistantConversation, AssistantConversationSummary, AssistantReply, AssistantSkill } from './types';
 import type { FileReference } from '../../client/record-feed';

package/src/admin/assistant/index.ts

@@ -1,6 +1,3 @@
-import type { AdminSection } from '../index';
-import { ASSISTANT_PERMISSIONS } from './AssistantPanel';
-import { ConversationsPage, MemoriesPage, SkillsPage } from './pages';
 
 export * from './types';
 export * from './data';
@@ -11,11 +8,4 @@ export * from './launchers';
 export * from './pages';
 export * from './streaming';
 
-export const ASSISTANT_ADMIN_SECTION: AdminSection = {
-    id: 'assistant', basePath: 'assistant', title: 'Assistant', icon: 'bi-stars', navigationGroup: 'assistant', permissions: ASSISTANT_PERMISSIONS,
-    routes: [
-        { path: 'conversations', label: 'Conversations', component: ConversationsPage, permissions: ASSISTANT_PERMISSIONS },
-        { path: 'skills', label: 'Skills', component: SkillsPage, permissions: ASSISTANT_PERMISSIONS },
-        { path: 'memories', label: 'Memory', component: MemoriesPage, permissions: ['sys.assistant'] },
-    ],
-};
+export { ASSISTANT_ADMIN_SECTION } from '../domains/assistant';

package/src/admin/assistant/launchers.tsx

@@ -1,17 +1,11 @@
 import { useEffect, useRef, useState, type MouseEvent } from 'react';
-import { useCan } from '../../client';
-import { useRightPanel } from '../../ui';
+import { useCan } from '../../client/runtime';
+import { useRightPanel } from '../../ui/RightPanel';
 import { SECURITY_VIEW_PERMS } from '../security-permissions';
-import { AssistantPanel, ASSISTANT_PERMISSIONS } from './AssistantPanel';
+import { ASSISTANT_PERMISSIONS } from './permissions';
 import { createAssistantContext } from './api';
 
-export function AssistantLauncher() {
-    const { can } = useCan(ASSISTANT_PERMISSIONS);
-    const panel = useRightPanel();
-    useEffect(() => { if (!can && panel.descriptor?.key.startsWith('assistant:')) panel.close(); }, [can, panel]);
-    if (!can) return null;
-    return <button type="button" className="btn-icon" title="Open Assistant" aria-label="Open Assistant" aria-pressed={panel.descriptor?.key === 'assistant:new'} onClick={(event) => panel.open({ key: 'assistant:new', title: 'Assistant', render: (context) => <AssistantPanel context={context} /> }, event.currentTarget)}><i className="bi bi-stars" aria-hidden="true" /></button>;
-}
+export { AssistantLauncher } from './AssistantLauncher';
 
 export function AssistantContextLauncher({ model, pk, label = 'Ask Assistant' }: { model: 'incident.Incident' | 'incident.Ticket'; pk: number; label?: string }) {
     const assistant = useCan(ASSISTANT_PERMISSIONS);
@@ -25,7 +19,7 @@ export function AssistantContextLauncher({ model, pk, label = 'Ask Assistant' }:
     if (!assistant.can || !security.can) return null;
     const launch = async (event: MouseEvent<HTMLButtonElement>) => {
         const launcher = event.currentTarget; const run = ++generation.current; setLoading(true); setError('');
-        try { const conversation = await createAssistantContext(model, pk); if (generation.current !== run) return; panel.open({ key: `assistant:context:${model}:${pk}:${conversation.id}`, title: `Assistant · ${model === 'incident.Incident' ? 'Incident' : 'Ticket'} #${pk}`, render: (context) => <AssistantPanel context={context} initialConversation={conversation} /> }, launcher); }
+        try { const [conversation, { AssistantPanel }] = await Promise.all([createAssistantContext(model, pk), import('./AssistantPanel')]); if (generation.current !== run) return; panel.open({ key: `assistant:context:${model}:${pk}:${conversation.id}`, title: `Assistant · ${model === 'incident.Incident' ? 'Incident' : 'Ticket'} #${pk}`, render: (context) => <AssistantPanel context={context} initialConversation={conversation} /> }, launcher); }
         catch (cause) { if (generation.current === run) setError(cause instanceof Error ? cause.message : 'Could not create context'); }
         finally { if (generation.current === run) setLoading(false); }
     };

package/src/admin/assistant/pages.tsx

@@ -1,5 +1,5 @@
 import { useCallback, useEffect, useRef, useState } from 'react';
-import { mojoList, useCan, useMe, useRealtime, useRealtimeStatus } from '../../client';
+import { mojoList, useCan, useMe, useRealtime, useRealtimeStatus } from '../../client/runtime';
 import { Badge, fmt, modal, toast } from '../../ui';
 import { AssistantFeed } from './AssistantFeed';
 import { deleteAssistantConversation, deleteAssistantMemory, deleteAssistantSkill, getAssistantConversation, getAssistantMemory, getAssistantSkill, listAssistantConversations, listAssistantSkills, saveAssistantMemory, sendAssistantMessage } from './api';

package/src/admin/assistant/permissions.ts

@@ -0,0 +1 @@
+export const ASSISTANT_PERMISSIONS = ['sys.view_admin', 'sys.assistant'];