jupyterlab_ai_code_assistants_extension 1.2.282 → 1.2.288

package/README.md

@@ -10,7 +10,7 @@
 
 A full launcher and manager for every AI code assistant in JupyterLab - Claude Code, Codex, Kimi, Gemini and DeepSeek. Start, resume, fork, switch, and clean up CLI sessions from a side panel per assistant - one click lands you in the right terminal with the assistant already running, no duplicate tabs, no UUID hunting. One install replaces the separate `jupyterlab_claude_code_extension`, `jupyterlab_codex_extension` and `jupyterlab_kimi_code_extension` packages and migrates their settings and favourites automatically.
 
-![Claude Code Sessions panel](.resources/screenshot.png)
+![Claude Code panel](.resources/screenshot.png)
 
 ## Why this extension
 
@@ -36,6 +36,7 @@ Chat-panel extensions re-implement the agent loop and trail the real tool. This
 - **Conversation switcher** - a right-click "Switch and Manage Sessions" submenu lists a project's other conversations by name and short id. "Manage Sessions..." opens a searchable list with multi-select delete and copy-id
 - **Branch session** - fork the current conversation into a new named session from the right-click menu
 - **Rename session** - name a conversation from the right-click menu, and the panel shows the name the assistant itself kept
+- **Command line** - `jupyterlab-ai-code-assistants` lists, renames, moves, deletes, branches and switches the sessions of every assistant and refreshes the panels, from a terminal or an agent; every open panel shows the change at once
 - **Launch modes under each assistant's own name** - Claude's skip-permissions, Codex's approval bypass, Kimi's `--yolo` and Gemini's YOLO; unsafe variants carry a shield glyph
 - **Coloured terminal tabs** - each session's colour tints its terminal tab, and a branched session inherits its parent's colour. Claude's `/color` supplies a default and Kimi derives a stable one; Codex, Gemini and DeepSeek have no colour until you set one
 - **Your newest colour choice wins** - a colour set on a terminal tab is remembered for that conversation; a Kimi or DeepSeek conversation that has never been resumed, including one started with `+`, is the exception, because its id cannot be read yet. In Claude Code whichever of the tab colour and `/color` you used last wins, and Reset Tab Colour in the right-click menu hands back the colours you set by hand
@@ -76,6 +77,27 @@ pip install jupyterlab_ai_code_assistants_extension
 > [!WARNING]
 > `package.json` pins `webpack: 5.106.0` and `chalk: 4.1.2` in both `resolutions` and `overrides`. Do not remove these. webpack `>= 5.106.1` changed its module-federation share identifier format and crashes the unmaintained `license-webpack-plugin` (`split('=')[1].trim()`) that `@jupyterlab/builder` injects into every production build; the duplicate `chalk@2.4.2` pulled by `duplicate-package-checker-webpack-plugin` crashes on Node 24+ in the build-isolation install. Without the pins, `make publish` and CI fail on `python -m build`.
 
+## Command line
+
+The wheel installs `jupyterlab-ai-code-assistants`. It finds the running Jupyter server and its token, and changes sessions only through that server, so every open panel shows the change at once.
+
+```bash
+jupyterlab-ai-code-assistants                                   # the server and every assistant (status)
+jupyterlab-ai-code-assistants sessions list -a claude -p ~/project
+jupyterlab-ai-code-assistants sessions rename <id> "New name" -a kimi
+jupyterlab-ai-code-assistants sessions move <id> --to ~/other-project -a gemini
+jupyterlab-ai-code-assistants sessions delete <id> -a claude
+jupyterlab-ai-code-assistants sessions branch <id> -a claude --name "Experiment"
+jupyterlab-ai-code-assistants sessions switch <id> -a codex
+jupyterlab-ai-code-assistants refresh                           # after installing or removing an assistant CLI
+```
+
+- `--url` and `--json` go before the subcommand; `--url` chooses the server when several run
+- There is no token option: the token comes from `JUPYTERLAB_AI_CODE_ASSISTANTS_TOKEN`, else the server's runtime record, else `JUPYTERHUB_API_TOKEN`, `JPY_API_TOKEN` or `JUPYTER_TOKEN` for a loopback address
+- A session a running terminal holds is never moved or deleted, and a project's current session is never deleted
+- A Codex move forks the session into the target under a new id, which the command prints, and archives the source
+- `jupyterlab-ai-code-assistants --help` lists the exit codes; `--help` after a subcommand lists its options
+
 ## Agent skill
 
 The wheel ships a session-operations skill for coding agents at `share/jupyter/agents/skills/jupyterlab-ai-code-assistants-extension/SKILL.md`. It covers finding, moving, splitting, renaming and promoting sessions, copying a session into another project under a fresh id, the task-list environment variables, and running Claude Code against Kimi K3 or DeepSeek, with two references for the rest - `claude-operations.md` for how `claude -c` and `--resume` choose a session and how to repair, promote and pin one, and `cross-assistant-sessions.md` for reading, inventorying, taking over and resuming sessions of Claude Code, Codex, Kimi, Gemini and DeepSeek.

package/lib/core/panel.d.ts

@@ -87,6 +87,7 @@ export declare class AssistantSessionsPanel extends Widget {
      * the launch REACHED the server and was refused, and nothing retries it. */
     private _notifyLaunchError;
     private _logError;
+    /** `keepSame`: an answer equal to what is drawn leaves the rows in place. */
     private _fetch;
     private _toggleFavourite;
     /** The warning a deletion earns: with the trash setting on, a refused move
@@ -316,6 +317,13 @@ export declare class AssistantSessionsPanel extends Widget {
      * all. Returning null lets the popup fall back to its fork marker. */
     private _bgBadgeFor;
     private _startPolling;
+    /** The server says this assistant's sessions changed (ACC-CLI-227): read
+     * them through the poll's single-flight fetch. Unlike a poll tick it is
+     * never dropped. It waits for an open row context menu to close, and one
+     * that lands while a read is in flight reads once more after it, because
+     * that read may have been answered before the change. */
+    sessionsChanged(): void;
+    private _poll;
     private _stopPolling;
     private readonly _app;
     private readonly _descriptor;
@@ -375,9 +383,13 @@ export declare class AssistantSessionsPanel extends Widget {
     private _activeSession;
     private _activeRowEl;
     private _pollHandle;
-    /** The poll's own in-flight tick. Only the poll reads it - an explicit
-     * Refresh must always issue, however long the last poll is taking. */
+    /** The poll's own in-flight tick. Only the poll and a pushed change read it
+     * - an explicit Refresh must always issue, however long the last poll is
+     * taking. */
     private _polling;
+    /** A pushed change waits for the context menu to close or for the read in
+     * flight to answer - see `sessionsChanged`. */
+    private _changeWaits;
     /** Listing requests sent, and the number of the newest one drawn - see
      * `_fetch`. */
     private _fetchSent;

package/lib/core/panel.js

@@ -40,6 +40,18 @@ const INLINE_BRANCH_LIMIT = 5;
  * exports no token, so its absence is something to ask the command registry
  * about at click time rather than a build-time dependency (ACC-LNCH-155). */
 const BASIC_TERMINAL_LAUNCH = 'basic-terminal:launch';
+/** What a delete says about the conversations the server kept because a live
+ * terminal runs them (ACC-SESS-57); empty when it kept none. */
+function keptCopy(liveIds) {
+    var _a;
+    const kept = (_a = liveIds === null || liveIds === void 0 ? void 0 : liveIds.length) !== null && _a !== void 0 ? _a : 0;
+    if (kept === 0) {
+        return '';
+    }
+    return kept === 1
+        ? 'One conversation was kept, because a live terminal runs it.'
+        : `${kept} conversations were kept, because live terminals run them.`;
+}
 export const DEFAULT_PRESENTATION_MODE = 'name';
 const SECTION_LABELS = {
     favourites: 'Favorites',
@@ -173,9 +185,13 @@ export class AssistantSessionsPanel extends Widget {
         this._activeSession = null;
         this._activeRowEl = null;
         this._pollHandle = null;
-        /** The poll's own in-flight tick. Only the poll reads it - an explicit
-         * Refresh must always issue, however long the last poll is taking. */
+        /** The poll's own in-flight tick. Only the poll and a pushed change read it
+         * - an explicit Refresh must always issue, however long the last poll is
+         * taking. */
         this._polling = null;
+        /** A pushed change waits for the context menu to close or for the read in
+         * flight to answer - see `sessionsChanged`. */
+        this._changeWaits = false;
         /** Listing requests sent, and the number of the newest one drawn - see
          * `_fetch`. */
         this._fetchSent = 0;
@@ -633,7 +649,8 @@ export class AssistantSessionsPanel extends Widget {
         console.error(`${LOG_PREFIX}[${this._descriptor.id}]`, message);
     }
     // ------------------------------------------------------------------- data
-    async _fetch() {
+    /** `keepSame`: an answer equal to what is drawn leaves the rows in place. */
+    async _fetch(keepSame = false) {
         var _a;
         // This request's place in the order. Requests answer in any order, and an
         // answer older than the one already drawn is dropped (DEF-PANE-344).
@@ -647,10 +664,16 @@ export class AssistantSessionsPanel extends Widget {
         this._fetchDrawn = request;
         // A project removed at or after this listing was sent must not be drawn
         // back from the answer (DEF-PANE-351-WRITE-ORDER).
-        this._sessions = ((_a = data.sessions) !== null && _a !== void 0 ? _a : []).filter(s => { var _a; return ((_a = this._removedAt.get(s.encoded_path)) !== null && _a !== void 0 ? _a : 0) < request; });
+        const sessions = ((_a = data.sessions) !== null && _a !== void 0 ? _a : []).filter(s => { var _a; return ((_a = this._removedAt.get(s.encoded_path)) !== null && _a !== void 0 ? _a : 0) < request; });
         this._setInlineError(null);
-        this._terminals.setSessions(this._sessions);
-        this._render();
+        // A redraw replaces every row, and the row a click is on with it
+        // (DEF-PANE-370-OWN-PUSH).
+        if (!keepSame ||
+            JSON.stringify(sessions) !== JSON.stringify(this._sessions)) {
+            this._sessions = sessions;
+            this._terminals.setSessions(this._sessions);
+            this._render();
+        }
         // Best-effort tinting; never let a colour failure break the fetch.
         void this._colours.load().then(() => this._terminals.reconcileColours());
     }
@@ -668,8 +691,9 @@ export class AssistantSessionsPanel extends Widget {
             });
             // A listing sent before the write may still be drawn, and a poll may
             // have replaced the row this wrote; this one is answered after the write
-            // (DEF-PANE-351).
-            void this._fetch().catch(() => undefined);
+            // (DEF-PANE-351). When it answers what the star above drew, the rows
+            // stay: the star is redrawn once.
+            void this._fetch(true).catch(() => undefined);
         }
         catch (err) {
             session.favourite = !next; // roll back
@@ -899,7 +923,12 @@ export class AssistantSessionsPanel extends Widget {
             // The kept listing names conversations that may have just gone.
             this._branchCache = null;
             bar.value = 1;
-            message.textContent = `Removed ${data.removed_count} parallel session${data.removed_count === 1 ? '' : 's'}.`;
+            message.textContent = [
+                `Removed ${data.removed_count} parallel session${data.removed_count === 1 ? '' : 's'}.`,
+                keptCopy(data.live_ids)
+            ]
+                .filter(part => part)
+                .join(' ');
             // Refresh so the row's conversation count and menu label update.
             await this._fetch();
         }
@@ -1502,6 +1531,10 @@ export class AssistantSessionsPanel extends Widget {
             await this._colours.forget((_a = result.removed_ids) !== null && _a !== void 0 ? _a : sessionIds);
             // The kept listing names conversations that may have just gone.
             this._branchCache = null;
+            const kept = keptCopy(result.live_ids);
+            if (kept) {
+                Notification.info(kept, { autoClose: 4000 });
+            }
             return result.removed_count;
         }
         catch (err) {
@@ -2420,6 +2453,11 @@ export class AssistantSessionsPanel extends Widget {
             // callback still needs to read it. The field is overwritten on the next
             // contextmenu open.
             this._setActiveRow(null);
+            // A change pushed while the menu was open reads now. A microtask later,
+            // because the menu is still attached while this signal fires.
+            if (this._changeWaits) {
+                queueMicrotask(() => this.sessionsChanged());
+            }
         });
     }
     _menu(commands = this._commands) {
@@ -2698,13 +2736,36 @@ export class AssistantSessionsPanel extends Widget {
             if (this._polling !== null) {
                 return;
             }
-            this._polling = this._fetch()
-                .catch(err => this._showError(err))
-                .finally(() => {
-                this._polling = null;
-            });
+            this._poll();
         }, POLL_INTERVAL_MS);
     }
+    /** The server says this assistant's sessions changed (ACC-CLI-227): read
+     * them through the poll's single-flight fetch. Unlike a poll tick it is
+     * never dropped. It waits for an open row context menu to close, and one
+     * that lands while a read is in flight reads once more after it, because
+     * that read may have been answered before the change. */
+    sessionsChanged() {
+        if (this.isDisposed) {
+            return;
+        }
+        if (this._contextMenu.isAttached || this._polling !== null) {
+            this._changeWaits = true;
+            return;
+        }
+        this._poll();
+    }
+    _poll() {
+        // A read sent now answers every change pushed before it.
+        this._changeWaits = false;
+        this._polling = this._fetch()
+            .catch(err => this._showError(err))
+            .finally(() => {
+            this._polling = null;
+            if (this._changeWaits) {
+                this.sessionsChanged();
+            }
+        });
+    }
     _stopPolling() {
         if (this._pollHandle !== null) {
             window.clearInterval(this._pollHandle);

package/lib/core/request.d.ts

@@ -1,6 +1,11 @@
 import { ServerConnection } from '@jupyterlab/services';
 /** The server extension's API namespace. Every route lives under it. */
 export declare const API_NAMESPACE = "jupyterlab-ai-code-assistants-extension";
+/** This window's name, sent with every request in {@link WINDOW_HEADER}. The
+ * server names it in the push a change causes, and this window skips that
+ * push: its panel re-reads after every write it makes (DEF-PANE-370-OWN-PUSH). */
+export declare const WINDOW_ID: string;
+export declare const WINDOW_HEADER = "X-AI-Assistants-Window";
 /**
  * DEF-72: how long a single server call may run before the client gives up.
  *

package/lib/core/request.js

@@ -1,8 +1,14 @@
 import { URLExt } from '@jupyterlab/coreutils';
 import { ServerConnection } from '@jupyterlab/services';
+import { UUID } from '@lumino/coreutils';
 import { LOG_PREFIX } from './registry';
 /** The server extension's API namespace. Every route lives under it. */
 export const API_NAMESPACE = 'jupyterlab-ai-code-assistants-extension';
+/** This window's name, sent with every request in {@link WINDOW_HEADER}. The
+ * server names it in the push a change causes, and this window skips that
+ * push: its panel re-reads after every write it makes (DEF-PANE-370-OWN-PUSH). */
+export const WINDOW_ID = UUID.uuid4();
+export const WINDOW_HEADER = 'X-AI-Assistants-Window';
 /**
  * DEF-72: how long a single server call may run before the client gives up.
  *
@@ -68,6 +74,15 @@ export function isRequestTimeout(err) {
 export async function requestAPI(endPoint, serverSettings, init = {}) {
     var _a, _b;
     const requestUrl = URLExt.join(serverSettings.baseUrl, API_NAMESPACE, endPoint);
+    // shortcut: a `Headers` instance in `init.headers` would be dropped here; no
+    // caller passes one.
+    init = {
+        ...init,
+        headers: {
+            ...init.headers,
+            [WINDOW_HEADER]: WINDOW_ID
+        }
+    };
     // DEF-72: `ServerConnection.makeRequest` sets no deadline of its own, so
     // without this a wedged server holds the call for as long as the browser
     // will hold the socket. Hand-rolled rather than `AbortSignal.timeout`, which

package/lib/core/types.d.ts

@@ -163,8 +163,12 @@ export interface IDisposalReport {
     removed_ids: string[];
 }
 export type IRemoveResponse = IDisposalReport;
-export type ICleanupResponse = IDisposalReport;
-export type IDeleteSessionsResponse = IDisposalReport;
+/** A delete of chosen conversations also names the ones it kept because a
+ * live terminal runs them (ACC-SESS-57). */
+export interface IDeleteSessionsResponse extends IDisposalReport {
+    live_ids: string[];
+}
+export type ICleanupResponse = IDeleteSessionsResponse;
 export interface IBranch {
     session_id: string;
     file_mtime: number;

package/lib/index.js

@@ -1,5 +1,6 @@
 import { ILabShell, ILayoutRestorer } from '@jupyterlab/application';
 import { ICommandPalette, Notification } from '@jupyterlab/apputils';
+import { URLExt } from '@jupyterlab/coreutils';
 import { IDefaultFileBrowser } from '@jupyterlab/filebrowser';
 import { ILauncher } from '@jupyterlab/launcher';
 import { ISettingRegistry } from '@jupyterlab/settingregistry';
@@ -11,7 +12,7 @@ import { launcherTileIcon, providerIcon } from './core/icons';
 import { DEFAULT_RECENT_LIMIT } from './core/limits';
 import { AssistantSessionsPanel, DEFAULT_PRESENTATION_MODE, MOVE_PANELS_COMMAND, SYNC_FILE_BROWSER_COMMAND, commandId, panelWidgetId } from './core/panel';
 import { LOG_PREFIX, ProviderRegistry } from './core/registry';
-import { requestAPI } from './core/request';
+import { API_NAMESPACE, requestAPI, WINDOW_ID } from './core/request';
 import { PROVIDERS } from './providers';
 /** Which sidebar the panels dock into unless the user says otherwise. */
 const DEFAULT_SIDEBAR = 'right';
@@ -21,9 +22,10 @@ const PLUGIN_ID = 'jupyterlab_ai_code_assistants_extension:plugin';
 const SHELL_PLUGIN_ID = '@jupyterlab/application-extension:shell';
 /** Sidebar rank, shared by every panel so they dock together. */
 const PANEL_RANK = 600;
-/** How often the server is re-asked which assistants are available, so a CLI
- * installed while JupyterLab runs surfaces without a reload. */
-const STATUS_INTERVAL_MS = 60000;
+/** The events socket reopens after a drop on a doubling delay, from the base
+ * up to the cap (the house notifications stream's values). */
+const RECONNECT_BASE_MS = 5000;
+const RECONNECT_MAX_MS = 60000;
 /** Launcher section every assistant tile lands in. */
 const LAUNCHER_CATEGORY = 'AI Assistants';
 /** Where that section sits. The Launcher ranks Notebook 0, Console 20 and
@@ -108,8 +110,8 @@ const plugin = {
                 });
             }
             catch (err) {
-                // No cadence named: this also prints from the activation probe, before
-                // the interval and the wake listeners are armed (DEF-122).
+                // No cadence named: there is none, and this also prints from the
+                // activation probe, before the wake listeners are armed (DEF-122).
                 console.warn(`${LOG_PREFIX} status probe failed; the last known roster stands (every enabled assistant, when there is none yet) until a later probe answers.`, err);
             }
         };
@@ -189,7 +191,9 @@ const plugin = {
                 // survives a reload independently of the others.
                 restorer === null || restorer === void 0 ? void 0 : restorer.add(panel, panelWidgetId(id));
                 const command = app.commands.addCommand(commandId(id, 'refresh'), {
-                    label: `Refresh ${module.descriptor.panelTitle}`,
+                    // The panel title is the assistant name alone (ACC-PANE-232); the
+                    // command still names what it refreshes.
+                    label: `Refresh ${module.descriptor.panelTitle} Sessions`,
                     // Takes no arguments, which is what `null` says here.
                     describedBy: { args: null },
                     execute: () => panel.refresh()
@@ -413,24 +417,49 @@ const plugin = {
                 }
             }
         };
-        // A suspended network stack - laptop asleep, tab backgrounded - is exactly
-        // when the probe fails, and the slow cadence below would leave the roster
-        // stale for up to a minute after the machine comes back. A wake fires
-        // both events, so it costs two probes; deliberately, because a guard that
-        // let the second join the first answered the wake with a request issued
-        // before it, and starved the interval below of its own tick (DEF-117).
+        // No timer checks which assistants are installed (ACC-PROV-230). The check
+        // runs at activation, when the tab becomes visible, when the network comes
+        // back and when the events socket reopens after a drop; a `refresh` push
+        // carries its roster and needs no request. Triggers that arrive before the
+        // request goes out - one macrotask - share it, and one request serves every
+        // panel of the window (ACC-PROV-231). A trigger while a request is in
+        // flight queues exactly one more after it: a wake is never answered by a
+        // request sent before it (DEF-117).
         // Heard from here, before the first await: a wake before the listeners are
         // armed below is only remembered, because a reconcile before the settings
         // load reads the enabled-by-default fallback and docks assistants the user
         // disabled; one status check answers it once they are armed (DEF-GUARD-122).
         let armed = false;
         let wokeDuringActivation = false;
+        /** A status request is queued or in flight. */
+        let probing = false;
+        /** A trigger arrived that the request in flight was sent before. */
+        let wokeAgain = false;
         const reprobe = () => {
             if (!armed) {
                 wokeDuringActivation = true;
                 return;
             }
-            void probeStatus().then(reconcile);
+            wokeAgain = true;
+            if (probing) {
+                return;
+            }
+            probing = true;
+            const send = () => {
+                wokeAgain = false;
+                void probeStatus()
+                    .then(reconcile)
+                    .finally(() => {
+                    if (wokeAgain) {
+                        send();
+                    }
+                    else {
+                        probing = false;
+                    }
+                });
+            };
+            // Runs once per trigger burst, never on a cadence.
+            window.setTimeout(send, 0);
         };
         window.addEventListener('online', reprobe);
         document.addEventListener('visibilitychange', () => {
@@ -510,11 +539,6 @@ const plugin = {
         });
         await migrate();
         reconcile();
-        // Re-probe on a slow cadence so a binary installed (or removed) while
-        // JupyterLab runs takes effect on the next refresh, without a reload.
-        window.setInterval(() => {
-            void probeStatus().then(reconcile);
-        }, STATUS_INTERVAL_MS);
         armed = true;
         if (wokeDuringActivation) {
             reprobe();
@@ -552,6 +576,72 @@ const plugin = {
                 channel.postMessage('changed');
             });
         }
+        // One events socket per window: the server pushes a message after every
+        // change a route makes, whoever asked for it - the command line included
+        // (ACC-CLI-227, ACC-CLI-228). Opened last, as the house notifications
+        // stream is, so nothing it throws can take the panels down with it.
+        let eventsUrl = URLExt.join(serverSettings.wsUrl, API_NAMESPACE, 'events');
+        // Gated on appendToken, as @jupyterlab/services does for its own sockets:
+        // a same-host session carries the handshake in its cookie.
+        if (serverSettings.appendToken && serverSettings.token) {
+            eventsUrl += `?token=${encodeURIComponent(serverSettings.token)}`;
+        }
+        let socket = null;
+        /** Closes since the last open; non-zero means pushes may have been missed. */
+        let drops = 0;
+        let reopenTimer;
+        const openEvents = () => {
+            window.clearTimeout(reopenTimer);
+            const ws = new serverSettings.WebSocket(eventsUrl);
+            socket = ws;
+            ws.onopen = () => {
+                if (drops > 0) {
+                    // Whatever was pushed while the socket was closed: one status check
+                    // and one read per panel (the network-back trigger of ACC-PROV-230).
+                    drops = 0;
+                    reprobe();
+                    live.forEach(entry => entry.panel.sessionsChanged());
+                }
+            };
+            ws.onmessage = (event) => {
+                var _a, _b;
+                const message = JSON.parse(event.data);
+                if (message.type === 'sessions-changed') {
+                    // This window's own change: the panel that made it re-reads after
+                    // the write, and a second read redraws every row again
+                    // (DEF-PANE-370-OWN-PUSH).
+                    if (message.window !== WINDOW_ID) {
+                        (_b = live.get((_a = message.provider) !== null && _a !== void 0 ? _a : '')) === null || _b === void 0 ? void 0 : _b.panel.sessionsChanged();
+                    }
+                }
+                else if (message.type === 'refresh' && message.status) {
+                    // The server probed for this push; its roster needs no request.
+                    status = message.status;
+                    reconcile();
+                    live.forEach(entry => entry.panel.sessionsChanged());
+                }
+            };
+            ws.onclose = () => {
+                socket = null;
+                drops += 1;
+                // This timer only reopens the socket; it checks nothing.
+                reopenTimer = window.setTimeout(openEvents, Math.min(RECONNECT_BASE_MS * 2 ** (drops - 1), RECONNECT_MAX_MS));
+            };
+            ws.onerror = () => ws.close();
+        };
+        // A closed socket reopens at once when the tab is back or the network is.
+        const reopenEvents = () => {
+            if (socket === null) {
+                openEvents();
+            }
+        };
+        window.addEventListener('online', reopenEvents);
+        document.addEventListener('visibilitychange', () => {
+            if (document.visibilityState === 'visible') {
+                reopenEvents();
+            }
+        });
+        openEvents();
         console.log(`${LOG_PREFIX} ${live.size} of ${registry.ids.length} assistant panel(s) docked.`);
     }
 };

package/lib/providers/claude.js

@@ -30,7 +30,7 @@ const claudeSvgStr = `<svg xmlns="http://www.w3.org/2000/svg" viewBox="-0.433 -0
 export const descriptor = {
     id: 'claude',
     label: 'Claude Code',
-    panelTitle: 'Claude Code Sessions',
+    panelTitle: 'Claude Code',
     iconName: 'jupyterlab_ai_code_assistants_extension:claude',
     iconSvg: claudeSvgStr,
     cliBinary: 'claude',

package/lib/providers/codex.js

@@ -28,7 +28,7 @@ const BYPASS_MODE = 'dangerouslyBypassApprovalsAndSandbox';
 export const descriptor = {
     id: 'codex',
     label: 'Codex',
-    panelTitle: 'Codex Sessions',
+    panelTitle: 'Codex',
     iconName: 'jupyterlab_ai_code_assistants_extension:codex',
     iconSvg: codexSvgStr,
     cliBinary: 'codex',

package/lib/providers/deepseek.js

@@ -27,7 +27,7 @@ const deepseekSvgStr = `<svg xmlns="http://www.w3.org/2000/svg" viewBox="-2.5 -4
 export const descriptor = {
     id: 'deepseek',
     label: 'DeepSeek',
-    panelTitle: 'DeepSeek Sessions',
+    panelTitle: 'DeepSeek',
     iconName: 'jupyterlab_ai_code_assistants_extension:deepseek',
     iconSvg: deepseekSvgStr,
     cliBinary: 'dsh',

package/lib/providers/gemini.js

@@ -31,7 +31,7 @@ const YOLO_MODE = 'yoloMode';
 export const descriptor = {
     id: 'gemini',
     label: 'Gemini',
-    panelTitle: 'Gemini Sessions',
+    panelTitle: 'Gemini',
     iconName: 'jupyterlab_ai_code_assistants_extension:gemini',
     iconSvg: geminiSvgStr,
     cliBinary: 'gemini',

package/lib/providers/kimi.js

@@ -28,7 +28,7 @@ const kimiSvgStr = `<svg xmlns="http://www.w3.org/2000/svg" viewBox="-2.395 -1.8
 export const descriptor = {
     id: 'kimi',
     label: 'Kimi',
-    panelTitle: 'Kimi Code Sessions',
+    panelTitle: 'Kimi Code',
     iconName: 'jupyterlab_ai_code_assistants_extension:kimi',
     iconSvg: kimiSvgStr,
     cliBinary: 'kimi',

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "jupyterlab_ai_code_assistants_extension",
-    "version": "1.2.282",
+    "version": "1.2.288",
     "description": "A full launcher and manager for every AI code assistant in JupyterLab - Claude Code, Codex, Kimi, Gemini and DeepSeek. Start, resume, fork, switch, and clean up CLI sessions from a side panel per assistant - one click lands you in the right terminal with the assistant already running, no duplicate tabs, no UUID hunting.",
     "keywords": [
         "jupyter",

package/schema/plugin.json

@@ -42,7 +42,7 @@
     "providers.claude.enabled": {
       "type": "boolean",
       "title": "Claude Code: enabled",
-      "description": "Show the Claude Code Sessions panel. A panel appears only when this is on AND the `claude` binary is on PATH.",
+      "description": "Show the Claude Code panel. A panel appears only when this is on AND the `claude` binary is on PATH.",
       "default": true
     },
     "providers.claude.dangerouslySkipPermissions": {
@@ -54,7 +54,7 @@
     "providers.codex.enabled": {
       "type": "boolean",
       "title": "Codex: enabled",
-      "description": "Show the Codex Sessions panel. A panel appears only when this is on AND the `codex` binary is on PATH.",
+      "description": "Show the Codex panel. A panel appears only when this is on AND the `codex` binary is on PATH.",
       "default": true
     },
     "providers.codex.dangerouslyBypassApprovalsAndSandbox": {
@@ -66,13 +66,13 @@
     "providers.deepseek.enabled": {
       "type": "boolean",
       "title": "DeepSeek: enabled",
-      "description": "Show the DeepSeek Sessions panel. A panel appears only when this is on AND the `dsh` binary is on PATH.",
+      "description": "Show the DeepSeek panel. A panel appears only when this is on AND the `dsh` binary is on PATH.",
       "default": true
     },
     "providers.gemini.enabled": {
       "type": "boolean",
       "title": "Gemini: enabled",
-      "description": "Show the Gemini Sessions panel. A panel appears only when this is on AND the `gemini` binary is on PATH.",
+      "description": "Show the Gemini panel. A panel appears only when this is on AND the `gemini` binary is on PATH.",
       "default": true
     },
     "providers.gemini.yoloMode": {
@@ -84,7 +84,7 @@
     "providers.kimi.enabled": {
       "type": "boolean",
       "title": "Kimi: enabled",
-      "description": "Show the Kimi Code Sessions panel. A panel appears only when this is on AND the `kimi` binary is on PATH.",
+      "description": "Show the Kimi Code panel. A panel appears only when this is on AND the `kimi` binary is on PATH.",
       "default": true
     },
     "providers.kimi.yoloMode": {