@jupyter-ai/persona-manager 0.1.3 → 0.2.0-a1

package/lib/awareness.d.ts

@@ -1,26 +1,11 @@
 /**
- * Reading persona session information from a chat's Yjs awareness channel.
+ * Shared persona session data types.
  *
- * The persona-manager server extension broadcasts session info over awareness
- * instead of REST. This module gives frontends a typed, read-only view of it:
- *
- * - `PersonaManagerAwareness` reads the persona list the `PersonaManager`
- *   publishes under a fixed, hardcoded client ID.
- * - `PersonaAwareness` reads one persona's slot (model configuration, settings,
- *   usage, slash commands, writing status), keyed by that persona's Yjs client
- *   ID (reported in the persona list).
- *
- * These mirror the Python awareness helpers of the same names. They are
- * read-only: user selections ride on message metadata, not awareness.
- */
-import { IAwareness } from '@jupyter/ydoc';
-/**
- * The fixed Yjs client ID the `PersonaManager` publishes its persona list under.
- * A chosen 53-bit constant, hardcoded on both server and client so the browser
- * can find the manager's slot without a discovery request. Must match
- * `PERSONA_MANAGER_AWARENESS_CLIENT_ID` in the persona-manager Python package.
+ * These mirror the Pydantic models in the persona-manager Python package and are
+ * the payloads carried by the `personas` / `persona_state` Jupyter Events. The
+ * live, per-chat state built from those events lives in
+ * `PersonaManagerSessionState` / `PersonaSessionState` (see `./persona-events`).
  */
-export declare const PERSONA_MANAGER_AWARENESS_CLIENT_ID = 7133713371337;
 /** A selectable model. Mirrors `ModelOption` in the Python package. */
 export type ModelOption = {
     id: string;
@@ -91,62 +76,8 @@ export type PersonaOption = {
     id: string;
     name: string;
     avatar_url: string | null;
-    /** The Yjs client ID of this persona's awareness slot. */
-    yjs_client_id: number;
+    /** Deprecated: legacy Yjs client id, unused now that state rides events. */
+    yjs_client_id?: number;
 };
 export declare const EMPTY_USAGE: Usage;
-/**
- * A typed, read-only view of the `PersonaManager`'s awareness slot: the list of
- * personas in the chat. Construct it with `PersonaManagerAwareness.from()`,
- * which resolves once the manager has published its slot.
- */
-export declare class PersonaManagerAwareness {
-    private _awareness;
-    private constructor();
-    /**
-     * Resolve once the `PersonaManager` has published its slot under the fixed
-     * client ID, polling the awareness map until it appears (or rejecting after a
-     * bounded wait). Pass the chat's Yjs awareness object (e.g. from the chat
-     * model's shared model).
-     *
-     * Safe to `await` in any context: if the slot is already present it resolves
-     * on the first check, effectively immediately.
-     */
-    static from(awareness: IAwareness): Promise<PersonaManagerAwareness>;
-    /**
-     * The personas available in this chat. Empty if none are published. Pass an
-     * entry to `PersonaAwareness.from()` to read that persona's own slot.
-     */
-    get personas(): PersonaOption[];
-}
-/**
- * A typed, read-only view of one persona's awareness slot. Construct it with
- * `PersonaAwareness.from(awareness, personaOption)` — the `PersonaOption` comes
- * from `PersonaManagerAwareness.personas` and carries the persona's client ID.
- */
-export declare class PersonaAwareness {
-    private _awareness;
-    private _id;
-    private _clientId;
-    private constructor();
-    /** Build a view of the persona named by `option` (from the persona list). */
-    static from(awareness: IAwareness, option: PersonaOption): PersonaAwareness;
-    /** The persona's stable ID (from the persona list). */
-    get id(): string;
-    private get _state();
-    /** The persona's model configuration (current model, options, model settings). */
-    get model(): ModelConfiguration;
-    /** The persona's general (non-model) setting configurations. */
-    get settings(): SettingConfiguration[];
-    /** The token and cost usage the persona reports for the session. */
-    get usage(): Usage;
-    /** The slash commands the persona advertises. */
-    get slash_commands(): CommandOption[];
-    /**
-     * Whether the persona is currently writing: `false` when idle, or the ID of
-     * the message being written while streaming.
-     */
-    get isWriting(): boolean | string;
-    /** Whether this persona has published its state yet. */
-    get isReady(): boolean;
-}
+export declare const EMPTY_MODEL_CONFIGURATION: ModelConfiguration;

package/lib/awareness.js

@@ -1,25 +1,11 @@
 /**
- * Reading persona session information from a chat's Yjs awareness channel.
+ * Shared persona session data types.
  *
- * The persona-manager server extension broadcasts session info over awareness
- * instead of REST. This module gives frontends a typed, read-only view of it:
- *
- * - `PersonaManagerAwareness` reads the persona list the `PersonaManager`
- *   publishes under a fixed, hardcoded client ID.
- * - `PersonaAwareness` reads one persona's slot (model configuration, settings,
- *   usage, slash commands, writing status), keyed by that persona's Yjs client
- *   ID (reported in the persona list).
- *
- * These mirror the Python awareness helpers of the same names. They are
- * read-only: user selections ride on message metadata, not awareness.
+ * These mirror the Pydantic models in the persona-manager Python package and are
+ * the payloads carried by the `personas` / `persona_state` Jupyter Events. The
+ * live, per-chat state built from those events lives in
+ * `PersonaManagerSessionState` / `PersonaSessionState` (see `./persona-events`).
  */
-/**
- * The fixed Yjs client ID the `PersonaManager` publishes its persona list under.
- * A chosen 53-bit constant, hardcoded on both server and client so the browser
- * can find the manager's slot without a discovery request. Must match
- * `PERSONA_MANAGER_AWARENESS_CLIENT_ID` in the persona-manager Python package.
- */
-export const PERSONA_MANAGER_AWARENESS_CLIENT_ID = 7133713371337;
 export const EMPTY_USAGE = {
     context_tokens: null,
     context_size: null,
@@ -33,114 +19,8 @@ export const EMPTY_USAGE = {
     cost_amount: null,
     cost_currency: null
 };
-// Interval and attempt cap for `PersonaManagerAwareness.from()` polling. The
-// manager registers a moment after a chat opens, and a persona's agent session
-// can take 20s+ to initialize, so poll generously before giving up.
-const POLL_MS = 500;
-const MAX_POLLS = 120;
-const delay = (ms) => new Promise(resolve => setTimeout(resolve, ms));
-/**
- * A typed, read-only view of the `PersonaManager`'s awareness slot: the list of
- * personas in the chat. Construct it with `PersonaManagerAwareness.from()`,
- * which resolves once the manager has published its slot.
- */
-export class PersonaManagerAwareness {
-    constructor(_awareness) {
-        this._awareness = _awareness;
-    }
-    /**
-     * Resolve once the `PersonaManager` has published its slot under the fixed
-     * client ID, polling the awareness map until it appears (or rejecting after a
-     * bounded wait). Pass the chat's Yjs awareness object (e.g. from the chat
-     * model's shared model).
-     *
-     * Safe to `await` in any context: if the slot is already present it resolves
-     * on the first check, effectively immediately.
-     */
-    static async from(awareness) {
-        for (let i = 0; i < MAX_POLLS; i++) {
-            if (awareness.getStates().has(PERSONA_MANAGER_AWARENESS_CLIENT_ID)) {
-                return new PersonaManagerAwareness(awareness);
-            }
-            await delay(POLL_MS);
-        }
-        throw new Error('Timed out waiting for the PersonaManager awareness slot. Is the ' +
-            'jupyter-ai-persona-manager server extension installed and enabled?');
-    }
-    /**
-     * The personas available in this chat. Empty if none are published. Pass an
-     * entry to `PersonaAwareness.from()` to read that persona's own slot.
-     */
-    get personas() {
-        const state = this._awareness
-            .getStates()
-            .get(PERSONA_MANAGER_AWARENESS_CLIENT_ID);
-        const personas = state === null || state === void 0 ? void 0 : state.personas;
-        return Array.isArray(personas) ? personas : [];
-    }
-}
-/**
- * A typed, read-only view of one persona's awareness slot. Construct it with
- * `PersonaAwareness.from(awareness, personaOption)` — the `PersonaOption` comes
- * from `PersonaManagerAwareness.personas` and carries the persona's client ID.
- */
-export class PersonaAwareness {
-    constructor(_awareness, _id, _clientId) {
-        this._awareness = _awareness;
-        this._id = _id;
-        this._clientId = _clientId;
-    }
-    /** Build a view of the persona named by `option` (from the persona list). */
-    static from(awareness, option) {
-        return new PersonaAwareness(awareness, option.id, option.yjs_client_id);
-    }
-    /** The persona's stable ID (from the persona list). */
-    get id() {
-        return this._id;
-    }
-    get _state() {
-        return this._awareness.getStates().get(this._clientId);
-    }
-    /** The persona's model configuration (current model, options, model settings). */
-    get model() {
-        var _a, _b;
-        return ((_b = (_a = this._state) === null || _a === void 0 ? void 0 : _a.model) !== null && _b !== void 0 ? _b : {
-            current: null,
-            options: [],
-            settings: []
-        });
-    }
-    /** The persona's general (non-model) setting configurations. */
-    get settings() {
-        var _a, _b;
-        return (_b = (_a = this._state) === null || _a === void 0 ? void 0 : _a.settings) !== null && _b !== void 0 ? _b : [];
-    }
-    /** The token and cost usage the persona reports for the session. */
-    get usage() {
-        var _a, _b;
-        // Backfill from EMPTY_USAGE so fields a (possibly older) server never
-        // published read as null, as the type promises, not undefined.
-        return {
-            ...EMPTY_USAGE,
-            ...((_b = (_a = this._state) === null || _a === void 0 ? void 0 : _a.usage) !== null && _b !== void 0 ? _b : {})
-        };
-    }
-    /** The slash commands the persona advertises. */
-    get slash_commands() {
-        var _a, _b;
-        return (_b = (_a = this._state) === null || _a === void 0 ? void 0 : _a.slash_commands) !== null && _b !== void 0 ? _b : [];
-    }
-    /**
-     * Whether the persona is currently writing: `false` when idle, or the ID of
-     * the message being written while streaming.
-     */
-    get isWriting() {
-        var _a, _b;
-        return (_b = (_a = this._state) === null || _a === void 0 ? void 0 : _a.isWriting) !== null && _b !== void 0 ? _b : false;
-    }
-    /** Whether this persona has published its state yet. */
-    get isReady() {
-        var _a;
-        return ((_a = this._state) === null || _a === void 0 ? void 0 : _a.model) !== undefined;
-    }
-}
+export const EMPTY_MODEL_CONFIGURATION = {
+    current: null,
+    options: [],
+    settings: []
+};

package/lib/index.d.ts

@@ -1,7 +1,9 @@
 import { JupyterFrontEndPlugin } from '@jupyterlab/application';
 import { IInputToolbarRegistryFactory } from '@jupyter/chat';
 import { IPersonaControlRegistry } from './persona-control-registry';
+import { PersonaSessionRegistry } from './persona-events';
 export * from './awareness';
+export * from './persona-events';
 export * from './persona-control-registry';
-declare const _default: (JupyterFrontEndPlugin<void> | JupyterFrontEndPlugin<IPersonaControlRegistry> | JupyterFrontEndPlugin<IInputToolbarRegistryFactory>)[];
+declare const _default: (JupyterFrontEndPlugin<void> | JupyterFrontEndPlugin<PersonaSessionRegistry> | JupyterFrontEndPlugin<IPersonaControlRegistry> | JupyterFrontEndPlugin<IInputToolbarRegistryFactory>)[];
 export default _default;

package/lib/index.js

@@ -1,11 +1,14 @@
 import { IChatCommandRegistry, IInputToolbarRegistryFactory, InputToolbarRegistry } from '@jupyter/chat';
+import { IEventListener } from 'jupyterlab-eventlistener';
 import { PersonaControls } from './persona-controls';
 import { IPersonaControlRegistry, PersonaControlRegistry } from './persona-control-registry';
+import { IPersonaSessionRegistry, PersonaSessionRegistry } from './persona-events';
 import { SLASH_COMMAND_PROVIDER_ID, SlashCommandProvider } from './slash-commands';
 import { StopButton } from './stop-button';
-// Public awareness API: typed, read-only views of the persona-manager and
-// persona awareness slots, for consumers building on the awareness channel.
+// Public persona session data types (event payloads).
 export * from './awareness';
+// Public persona session-state models + registry (fed by Jupyter Events).
+export * from './persona-events';
 // Public API for contributing controls to the persona controls toolbar.
 export * from './persona-control-registry';
 /**
@@ -19,17 +22,31 @@ const plugin = {
         console.log('JupyterLab extension @jupyter-ai/persona-manager is activated!');
     }
 };
+/**
+ * Plugin that provides the shared per-chat persona session-state registry,
+ * fed by Jupyter Events via `jupyterlab-eventlistener`.
+ */
+const sessionRegistryPlugin = {
+    id: '@jupyter-ai/persona-manager:session-registry',
+    description: 'Provides the per-chat persona session-state registry (fed by Jupyter Events).',
+    autoStart: true,
+    provides: IPersonaSessionRegistry,
+    requires: [IEventListener],
+    activate: (app, eventListener) => {
+        return new PersonaSessionRegistry(eventListener);
+    }
+};
 /**
  * Plugin registering slash-command completions read from the selected
- * persona's awareness slot.
+ * persona's session state (fed by Jupyter Events).
  */
 const slashCommandPlugin = {
     id: SLASH_COMMAND_PROVIDER_ID,
     description: 'Adds support for slash commands in Jupyter AI.',
     autoStart: true,
-    requires: [IChatCommandRegistry],
-    activate: (app, registry) => {
-        registry.addProvider(new SlashCommandProvider());
+    requires: [IChatCommandRegistry, IPersonaSessionRegistry],
+    activate: (app, registry, sessionRegistry) => {
+        registry.addProvider(new SlashCommandProvider(sessionRegistry));
     }
 };
 /**
@@ -57,12 +74,11 @@ const toolbarPlugin = {
     description: 'Provides the chat input toolbar with persona controls.',
     autoStart: true,
     provides: IInputToolbarRegistryFactory,
-    requires: [IPersonaControlRegistry],
-    activate: (app, controlRegistry) => {
-        // Wrap the persona controls to inject the control registry, which the
-        // generic toolbar-item props don't carry. Contributed controls (e.g. a
-        // persona's settings button) render for the selected persona.
-        const PersonaControlsItem = (itemProps) => PersonaControls({ ...itemProps, controlRegistry });
+    requires: [IPersonaControlRegistry, IPersonaSessionRegistry],
+    activate: (app, controlRegistry, sessionRegistry) => {
+        // Wrap the persona controls to inject the control + session registries,
+        // which the generic toolbar-item props don't carry.
+        const PersonaControlsItem = (itemProps) => PersonaControls({ ...itemProps, controlRegistry, sessionRegistry });
         return {
             create: () => {
                 // Start with the default toolbar (Send, Attach, Cancel, SaveEdit)
@@ -86,6 +102,7 @@ const toolbarPlugin = {
 };
 export default [
     plugin,
+    sessionRegistryPlugin,
     slashCommandPlugin,
     controlRegistryPlugin,
     toolbarPlugin

package/lib/persona-controls.d.ts

@@ -1,5 +1,6 @@
 import { InputToolbarRegistry } from '@jupyter/chat';
-import { PersonaAwareness, PersonaOption, Usage } from './awareness';
+import { PersonaOption, Usage } from './awareness';
+import { PersonaSessionRegistry, PersonaSessionState } from './persona-events';
 import { PersonaSettings } from './metadata';
 import { IPersonaControlRegistry } from './persona-control-registry';
 /**
@@ -26,7 +27,7 @@ export type Control = {
  * persona advertises models), its model settings, then its general settings.
  * The user's current selection seeds each control's `selection`.
  */
-export declare function buildControls(persona: PersonaAwareness | null, settings: PersonaSettings): Control[];
+export declare function buildControls(persona: PersonaSessionState | null, settings: PersonaSettings): Control[];
 /**
  * Decide which persona list the toolbar should display: a freshly read empty
  * list is treated as a transient blip (e.g. a Yjs awareness sync hiccup
@@ -56,7 +57,7 @@ export declare function reconcilePersonas(previous: PersonaOption[], next: Perso
  * result, or switching personas could show the previous persona's stale
  * state under the new selection.
  */
-export declare function reconcilePersonaState(previous: PersonaAwareness | null, next: PersonaAwareness | null): PersonaAwareness | null;
+export declare function reconcilePersonaState(previous: PersonaSessionState | null, next: PersonaSessionState | null): PersonaSessionState | null;
 /**
  * Decide how to reconcile the current selection with a freshly read persona
  * list: the new selection to apply, or `undefined` to keep the current one.
@@ -171,5 +172,10 @@ export declare function PersonaControls(props: InputToolbarRegistry.IToolbarItem
      * Optional so the component still works without a registry.
      */
     controlRegistry?: IPersonaControlRegistry;
+    /**
+     * The per-chat persona session-state registry (fed by Jupyter Events).
+     * Optional so the component still works without it (renders nothing).
+     */
+    sessionRegistry?: PersonaSessionRegistry;
 }): JSX.Element | null;
 export {};

package/lib/persona-controls.js

@@ -1,10 +1,10 @@
-import React, { useCallback, useEffect, useId, useLayoutEffect, useRef, useState } from 'react';
+import React, { useCallback, useEffect, useId, useLayoutEffect, useMemo, useRef, useState } from 'react';
 import { Button, ListItemText, ListSubheader, Menu, MenuItem, Popover, Skeleton, TextField } from '@mui/material';
 import ArrowDropDownIcon from '@mui/icons-material/ArrowDropDown';
 import CheckIcon from '@mui/icons-material/Check';
 import MoreHorizIcon from '@mui/icons-material/MoreHoriz';
 import { PageConfig } from '@jupyterlab/coreutils';
-import { EMPTY_USAGE, PersonaAwareness, PersonaManagerAwareness } from './awareness';
+import { EMPTY_USAGE } from './awareness';
 import { buildMessageMetadata, emptyPersonaSettings } from './metadata';
 const SELECTOR_CLASS = 'jp-jai-personaControls';
 const MENU_CLASS = 'jp-jai-controlMenu';
@@ -635,20 +635,16 @@ export function UsageChip(props) {
  */
 export function PersonaControls(props) {
     var _a, _b, _c, _d, _e, _f;
-    const { chatModel, model, controlRegistry } = props;
-    const awareness = (_a = chatModel === null || chatModel === void 0 ? void 0 : chatModel.awareness) !== null && _a !== void 0 ? _a : null;
-    // The manager's awareness view, resolved once its slot appears. Null until
-    // then. `PersonaManagerAwareness.from()` polls internally, so nothing here
-    // polls; once resolved, awareness `change` events drive all updates.
-    const [manager, setManager] = useState(null);
-    // Whether resolving the manager's slot failed (timed out, extension absent).
-    // Hides the loading placeholder along with the toolbar.
-    const [managerFailed, setManagerFailed] = useState(false);
-    // Whether the first persona-list read has completed after the manager
-    // resolved. Before that, an empty list means "still loading", not "this chat
-    // has no personas".
-    const [listRead, setListRead] = useState(false);
+    const { chatModel, model, controlRegistry, sessionRegistry } = props;
+    // The chat's server-root-relative path scopes persona events to this chat.
+    const path = (_a = chatModel === null || chatModel === void 0 ? void 0 : chatModel.name) !== null && _a !== void 0 ? _a : null;
+    // The per-chat persona session state, built from persona events and shared
+    // via the registry. Created on demand; discarded when the chat closes.
+    const managerState = useMemo(() => (sessionRegistry && path ? sessionRegistry.get(path) : null), [sessionRegistry, path]);
     const [personas, setPersonas] = useState([]);
+    // Whether a persona list has been received for this chat yet. Before that, an
+    // empty list means "still loading", not "this chat has no personas".
+    const [ready, setReady] = useState(false);
     const [selectedId, setSelectedId] = useState(DEFAULT_PERSONA_ID);
     const [personaState, setPersonaState] = useState(null);
     // Per-persona settings the user has chosen, indexed by persona ID. Remembers
@@ -665,86 +661,66 @@ export function PersonaControls(props) {
     const settings = selectedId
         ? ((_b = settingsCache[selectedId]) !== null && _b !== void 0 ? _b : emptyPersonaSettings())
         : emptyPersonaSettings();
-    // Resolve the manager's awareness view once the manager registers its slot.
-    useEffect(() => {
-        if (!awareness) {
-            return;
-        }
-        let cancelled = false;
-        PersonaManagerAwareness.from(awareness)
-            .then(pm => {
-            if (!cancelled) {
-                setManager(pm);
-            }
-        })
-            .catch(reason => {
-            // Manager never registered (e.g. extension disabled); the toolbar
-            // stays hidden. Surface why, or the empty toolbar is undiagnosable.
-            console.warn('Persona toolbar hidden:', reason);
-            if (!cancelled) {
-                setManagerFailed(true);
-            }
-        });
-        return () => {
-            cancelled = true;
-        };
-    }, [awareness]);
-    // Re-read the persona list from the manager view and reconcile the selection
-    // (see reconcileSelection for the decision rules). This is the reactive
-    // plumbing that replaces polling: a persona publishing or updating its state
-    // fires an awareness `change` event.
+    // Re-read the persona list from the session state and reconcile the
+    // selection (see reconcileSelection for the decision rules).
     const readManager = useCallback(() => {
-        if (!manager) {
+        if (!managerState) {
             return;
         }
-        const list = manager.personas;
+        const list = managerState.personas;
         setPersonas(prev => reconcilePersonas(prev, list));
         setSelectedId(current => {
             const next = reconcileSelection(list, current, userPicked.current);
             return next === undefined ? current : next;
         });
-    }, [manager]);
+    }, [managerState]);
+    // React to the session state's `changed` signal: re-read the persona list and
+    // readiness. This replaces the awareness `change` subscription — a persona
+    // publishing or updating its state fires `changed`.
     useEffect(() => {
-        if (!awareness || !manager) {
+        if (!managerState) {
             return;
         }
-        readManager();
-        setListRead(true);
-        const onChange = () => readManager();
-        awareness.on('change', onChange);
+        const sync = () => {
+            readManager();
+            setReady(managerState.ready);
+        };
+        sync();
+        managerState.changed.connect(sync);
         return () => {
-            awareness.off('change', onChange);
+            managerState.changed.disconnect(sync);
         };
-    }, [awareness, manager, readManager]);
-    // Build a view of the selected persona's slot from the manager's list, or
-    // null when nothing is selected / the persona isn't present yet.
-    const readSelectedPersona = () => {
-        if (!awareness || !manager || !selectedId) {
-            return null;
-        }
-        const option = manager.personas.find(p => p.id === selectedId);
-        return option ? PersonaAwareness.from(awareness, option) : null;
-    };
-    // Track the selected persona's view in state, re-reading on every awareness
-    // change (a persona updating usage, model, or commands) so the toolbar
-    // reflects the latest published state. The first read (right below)
-    // applies unconditionally, since it runs whenever `selectedId` itself
-    // changes and must reflect the newly selected persona, even a genuinely
-    // absent one; every later read goes through reconcilePersonaState so a
-    // transient blip doesn't blank this out - see its comment for why that
-    // matters more than it looks like it should.
+    }, [managerState, readManager]);
+    // Track the selected persona's state, re-reading on every change so the
+    // toolbar reflects the latest published model/usage/commands. The first read
+    // applies unconditionally (it runs whenever `selectedId` changes and must
+    // reflect the newly selected persona, even an absent one); later reads go
+    // through reconcilePersonaState so a transient absence doesn't blank it out.
     useEffect(() => {
-        if (!awareness || !manager || !selectedId) {
+        var _a;
+        if (!managerState || !selectedId) {
             setPersonaState(null);
             return;
         }
-        setPersonaState(readSelectedPersona());
-        const read = () => setPersonaState(prev => reconcilePersonaState(prev, readSelectedPersona()));
-        awareness.on('change', read);
+        setPersonaState((_a = managerState.getPersona(selectedId)) !== null && _a !== void 0 ? _a : null);
+        const read = () => setPersonaState(prev => { var _a; return reconcilePersonaState(prev, (_a = managerState.getPersona(selectedId)) !== null && _a !== void 0 ? _a : null); });
+        managerState.changed.connect(read);
+        return () => {
+            managerState.changed.disconnect(read);
+        };
+    }, [managerState, selectedId]);
+    // Discard this chat's session state when the chat model is disposed (chat
+    // closed), freeing its memory.
+    useEffect(() => {
+        if (!sessionRegistry || !path || !chatModel) {
+            return;
+        }
+        const onDisposed = () => sessionRegistry.discard(path);
+        chatModel.disposed.connect(onDisposed);
         return () => {
-            awareness.off('change', read);
+            chatModel.disposed.disconnect(onDisposed);
         };
-    }, [awareness, manager, selectedId]);
+    }, [sessionRegistry, path, chatModel]);
     // Stamp the current persona + its settings onto the input model's metadata,
     // so it rides out with the next message and the PersonaManager routes and
     // applies it. Keyed on a signature so we only write when it changes.
@@ -755,9 +731,12 @@ export function PersonaControls(props) {
     }, [model, metadataSignature]);
     // No personas yet. While the manager's slot or its first list read is still
     // pending, show a loading placeholder (on slow networks this takes seconds);
-    // once resolution failed or the chat genuinely has no personas, show nothing.
+    // once ready with no personas, show nothing.
     if (!personas.length) {
-        if (showLoadingPlaceholder(awareness !== null, manager !== null, managerFailed, listRead)) {
+        // Still loading while the session state exists but no persona list has
+        // arrived yet (events are in flight). Once ready with an empty list, or
+        // with no registry at all, render nothing.
+        if (managerState && !ready) {
             return React.createElement(LoadingPlaceholder, null);
         }
         return null;

package/lib/persona-events.d.ts

@@ -0,0 +1,88 @@
+import { IEventListener } from 'jupyterlab-eventlistener';
+import { Token } from '@lumino/coreutils';
+import { IDisposable } from '@lumino/disposable';
+import { ISignal } from '@lumino/signaling';
+import { CommandOption, ModelConfiguration, PersonaOption, SettingConfiguration, Usage } from './awareness';
+export declare const PERSONAS_EVENT_SCHEMA_ID = "https://schema.jupyter.org/jupyter_ai_persona_manager/personas/v1";
+export declare const PERSONA_STATE_EVENT_SCHEMA_ID = "https://schema.jupyter.org/jupyter_ai_persona_manager/persona_state/v1";
+/** The wire shape of a `persona_state` event. */
+type PersonaStatePayload = {
+    path?: string;
+    persona_id?: string;
+    model?: ModelConfiguration;
+    settings?: SettingConfiguration[];
+    usage?: Usage;
+    slash_commands?: CommandOption[];
+};
+/**
+ * One persona's live session state, built from a `persona_state` event.
+ * Immutable: each update produces a new instance, so React consumers see a new
+ * reference and re-render.
+ */
+export declare class PersonaSessionState {
+    readonly id: string;
+    constructor(id: string, payload?: PersonaStatePayload);
+    readonly model: ModelConfiguration;
+    readonly settings: SettingConfiguration[];
+    readonly usage: Usage;
+    readonly slash_commands: CommandOption[];
+}
+/**
+ * The per-chat manager session state: the persona list plus a
+ * `PersonaSessionState` per persona. Fires `changed` whenever the persona list
+ * or any persona's state updates, so React components re-render.
+ */
+export declare class PersonaManagerSessionState implements IDisposable {
+    readonly path: string;
+    constructor(path: string);
+    /** Emits whenever the persona list or a persona's state changes. */
+    get changed(): ISignal<this, void>;
+    /** Whether a `personas` event has been received for this chat yet. */
+    get ready(): boolean;
+    /** The personas advertised in this chat. */
+    get personas(): PersonaOption[];
+    /** A persona's session state, or undefined if it has not published yet. */
+    getPersona(id: string): PersonaSessionState | undefined;
+    /** Apply a `personas` event payload. */
+    updatePersonas(personas: PersonaOption[]): void;
+    /** Apply a `persona_state` event payload for one persona. */
+    updatePersonaState(personaId: string, payload: PersonaStatePayload): void;
+    get isDisposed(): boolean;
+    dispose(): void;
+    private _personasReceived;
+    private _personas;
+    private _states;
+    private _isDisposed;
+    private _changed;
+}
+/**
+ * Routes persona events to the correct per-chat `PersonaManagerSessionState`,
+ * creating one on demand and discarding it when the chat closes.
+ *
+ * A single instance is created by the plugin and shared with the toolbar
+ * controls and the slash-command provider.
+ */
+export declare class PersonaSessionRegistry {
+    constructor(eventListener: IEventListener);
+    /**
+     * Get (or create) the manager session state for a chat path. Components call
+     * this with their chat's `IChatModel.name`.
+     */
+    get(path: string): PersonaManagerSessionState;
+    /** Whether a manager session state exists for `path` (without creating one). */
+    has(path: string): boolean;
+    /**
+     * Discard a chat's session state and free its memory. Called when the client
+     * closes the chat (wired to the chat model's `disposed` signal).
+     */
+    discard(path: string): void;
+    private _onPersonasEvent;
+    private _onPersonaStateEvent;
+    private _byPath;
+}
+/**
+ * Plugin token for the shared `PersonaSessionRegistry`. Consumed by the toolbar
+ * controls and the slash-command provider.
+ */
+export declare const IPersonaSessionRegistry: Token<PersonaSessionRegistry>;
+export {};