jupyterlab_ai_code_assistants_extension 1.2.120 → 1.2.163

package/README.md

@@ -33,7 +33,7 @@ Chat-panel extensions re-implement the agent loop and trail the real tool. This
 - **File browser follows the opened session** - opening a session moves the JupyterLab file browser to that session's project folder (a setting, on by default); a right-click on a panel header toggles this and moves the panels between the left and right sidebars
 - **Launcher tiles** - every enabled assistant has a tile in an "AI Assistants" section of the JupyterLab Launcher (after Other, under the extension's own robot-head icon); a click opens the assistant in the file browser's current folder, resuming the folder's conversation when one exists and starting a new one otherwise, through the companion `jupyterlab_basic_terminal_extension` (installed automatically). Disable an assistant and its tile goes; disable them all and the section goes with them
 - **Your terminal's `claude -c` follows the panel** (Claude) - switching to a conversation makes plain `claude -c` in that project resume that same conversation, including one that has been compacted, which Claude Code otherwise refuses to continue. Launching repairs a compacted conversation the same way, but only switching moves what `claude -c` picks
-- **Conversation switcher** - a right-click "Switch and Manage Sessions" submenu lists a project's other conversations by name and short id with last-activity time; "Manage Sessions..." opens a searchable popup over the full list with multi-select delete and per-row open and copy-id buttons
+- **Conversation switcher** - a right-click "Switch and Manage Sessions" submenu lists a project's other conversations by name and short id with last-activity time; "Manage Sessions..." opens a searchable popup over the full list with multi-select delete, a per-row action that switches or opens according to the submenu it was opened from, and a copy-id button
 - **Branch session** - fork the current conversation into a new named session via the right-click menu; each assistant forks its own way (Claude's native `--fork-session`, Codex's app-server `thread/fork`, server-side copies for Kimi, Gemini and DeepSeek) behind the same menu item
 - **Rename session** - name a conversation from the right-click menu, and the name is written where the assistant itself reads it back: Claude gets the record its own `/rename` writes, Kimi a custom title, Gemini the chat's summary, DeepSeek its title event. The panel shows the name the assistant actually kept. Codex's name is set through Codex's own app-server, so its CLI lists the same name the panel shows
 - **Launch modes under each assistant's own name** - Claude's skip-permissions, Codex's approval bypass, Kimi's `--yolo`, Gemini's YOLO; unsafe variants carry a shield glyph in the launch menus
@@ -78,7 +78,7 @@ pip install jupyterlab_ai_code_assistants_extension
 
 ## 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.
+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.
 
 After `pip install`, with the Python that runs the lab:
 

package/lib/core/callback.js

@@ -1,5 +1,6 @@
 import { Dialog, Notification } from '@jupyterlab/apputils';
 import { Widget } from '@lumino/widgets';
+import { dialogRenderer } from './dialogs';
 import { requestAPI } from './request';
 /** The command that delivers a pasted login callback link. */
 export const CALLBACK_COMMAND = 'open:callback';
@@ -71,7 +72,8 @@ class CallbackDialog extends Dialog {
                 Dialog.okButton({ label: _trans.__('OK') })
             ],
             defaultButton: 1,
-            focusNodeSelector: 'input'
+            focusNodeSelector: 'input',
+            renderer: dialogRenderer
         });
         this._form = _form;
         this._send = _send;

package/lib/core/dialogs.d.ts

@@ -0,0 +1,16 @@
+import { Dialog } from '@jupyterlab/apputils';
+import { Widget } from '@lumino/widgets';
+/**
+ * The renderer every dialog of this extension is built with. It marks the
+ * footer, and `style/base.css` scopes its dialog rules - no focus rim on any
+ * button, the reject buttons (Cancel, and Close in the Open Callback popup) as
+ * secondary surface buttons so the fill alone marks the primary - to a dialog
+ * that holds the mark, so JupyterLab's own
+ * dialogs keep their look. A renderer is the one hook that also reaches the
+ * dialogs JupyterLab builds on our behalf: `InputDialog.getText` passes its
+ * options through, and takes no class.
+ */
+export declare class DialogRenderer extends Dialog.Renderer {
+    createFooter(buttons: ReadonlyArray<HTMLElement>, checkbox: HTMLElement | null): Widget;
+}
+export declare const dialogRenderer: DialogRenderer;

package/lib/core/dialogs.js

@@ -0,0 +1,19 @@
+import { Dialog } from '@jupyterlab/apputils';
+/**
+ * The renderer every dialog of this extension is built with. It marks the
+ * footer, and `style/base.css` scopes its dialog rules - no focus rim on any
+ * button, the reject buttons (Cancel, and Close in the Open Callback popup) as
+ * secondary surface buttons so the fill alone marks the primary - to a dialog
+ * that holds the mark, so JupyterLab's own
+ * dialogs keep their look. A renderer is the one hook that also reaches the
+ * dialogs JupyterLab builds on our behalf: `InputDialog.getText` passes its
+ * options through, and takes no class.
+ */
+export class DialogRenderer extends Dialog.Renderer {
+    createFooter(buttons, checkbox) {
+        const footer = super.createFooter(buttons, checkbox);
+        footer.addClass('jp-AiAssistantsPanel-dialogFooter');
+        return footer;
+    }
+}
+export const dialogRenderer = new DialogRenderer();

package/lib/core/icons.d.ts

@@ -10,7 +10,15 @@ export declare const branchIcon: LabIcon;
 export declare const switchIcon: LabIcon;
 export declare const filterIcon: LabIcon;
 export declare const statusDotIcon: LabIcon;
-/** Build (or reuse) the LabIcon for a provider's own glyph. */
+/**
+ * Build (or reuse) the LabIcon for a provider's own glyph.
+ *
+ * Every provider SVG carries a square viewBox centred on its art, with the
+ * art's larger side at 20/24 of the box - the inset of JupyterLab's own icons
+ * (the terminal icon draws 2..22 in a 24 box). The Launcher card, the sidebar
+ * tab and the menus each draw every icon in one box size, so the same inset
+ * gives every assistant the same visual size there (DEF-PANE-332).
+ */
 export declare function providerIcon(name: string, svgstr: string): LabIcon;
 /**
  * A provider's tile icon as the Launcher should draw it.

package/lib/core/icons.js

@@ -123,7 +123,15 @@ export const statusDotIcon = new LabIcon({
 // live settings toggle must resolve to the icon it built the first time
 // rather than construct a second one on every toggle.
 const _providerIcons = new Map();
-/** Build (or reuse) the LabIcon for a provider's own glyph. */
+/**
+ * Build (or reuse) the LabIcon for a provider's own glyph.
+ *
+ * Every provider SVG carries a square viewBox centred on its art, with the
+ * art's larger side at 20/24 of the box - the inset of JupyterLab's own icons
+ * (the terminal icon draws 2..22 in a 24 box). The Launcher card, the sidebar
+ * tab and the menus each draw every icon in one box size, so the same inset
+ * gives every assistant the same visual size there (DEF-PANE-332).
+ */
 export function providerIcon(name, svgstr) {
     let icon = _providerIcons.get(name);
     if (!icon) {

package/lib/core/panel.d.ts

@@ -45,14 +45,6 @@ export declare class AssistantSessionsPanel extends Widget {
     protected onBeforeHide(_msg: Message): void;
     protected onCloseRequest(msg: Message): void;
     private _buildShell;
-    /** Raise the click-time busy overlay. Each action gets a token, because an
-     * open and a branch can overlap; the overlay clears when the last one ends,
-     * and the label names the newest action still running. */
-    private _beginBusy;
-    private _endBusy;
-    /** Name the newest still-running action in the visible label and the live
-     * region, so neither keeps naming an action that ended. */
-    private _paintBusyMessage;
     /** Show / hide the filter input. Hiding also clears the active filter, so
      * the user never returns to an "invisible" filter narrowing the rows. */
     private _toggleFilterBar;
@@ -157,7 +149,7 @@ export declare class AssistantSessionsPanel extends Widget {
     /** The server mints the new id and answers with it before the terminal
      * opens - `server-copy` copies the store entry, `server-native` drives the
      * assistant's own non-interactive fork path - so one refresh surfaces the
-     * branch. */
+     * branch. `spinner` is the click's token, which the launch joins. */
     private _branchByServerCopy;
     /** Drop the hand-set colours of this project's conversations and re-tint
      * from the defaults at once, so nothing keeps showing a released colour
@@ -310,11 +302,6 @@ export declare class AssistantSessionsPanel extends Widget {
     private readonly _removingPaths;
     private _bodyEl;
     private _loadingEl;
-    private _busyEl;
-    private _busyLabelEl;
-    private _busyTextEl;
-    private _busySeq;
-    private _busyMessages;
     private _errorEl;
     private _refreshBtn;
     private _filterBtn;

package/lib/core/panel.js

@@ -5,6 +5,7 @@ import { CommandRegistry } from '@lumino/commands';
 import { UUID } from '@lumino/coreutils';
 import { Widget } from '@lumino/widgets';
 import { ColourStore } from './colour';
+import { dialogRenderer } from './dialogs';
 import { branchMenuLabel, shortSessionId } from './labels';
 import { addIcon, branchIcon, cleanupIcon, filterIcon, providerIcon, refreshIcon, removeIcon, shieldIcon, starFilledIcon, statusDotIcon, switchIcon } from './icons';
 import { DEFAULT_RECENT_LIMIT, MAX_RECENT_LIMIT, MIN_RECENT_LIMIT } from './limits';
@@ -12,7 +13,7 @@ import { resolveLaunchMode, resolvedLaunchModeEntry } from './modes';
 import { showManageSessionsPopup } from './popup';
 import { LOG_PREFIX } from './registry';
 import { isRequestTimeout, isResponseStatus, requestProvider, withQuery } from './request';
-import { TerminalManager } from './terminals';
+import { TerminalManager, beginSpinner, endSpinner } from './terminals';
 // Rows refresh on this cadence. It is also what refreshes whatever roster the
 // server caches for the context menu, so raising it past the server's cache
 // horizon leaves that snapshot stale at every menu open.
@@ -112,11 +113,6 @@ export class AssistantSessionsPanel extends Widget {
         this._deleteToTrash = true;
         this._removingPaths = new Set();
         this._loadingEl = null;
-        this._busyEl = null;
-        this._busyLabelEl = null;
-        this._busyTextEl = null;
-        this._busySeq = 0;
-        this._busyMessages = new Map();
         this._errorEl = null;
         this._refreshBtn = null;
         this._filterBtn = null;
@@ -188,13 +184,7 @@ export class AssistantSessionsPanel extends Widget {
         return this._descriptor;
     }
     dispose() {
-        var _a;
         this._stopPolling();
-        // The busy overlay lives on the shell, outside this widget's tree, so
-        // removing the panel does not remove it. Left behind it would show a
-        // spinner for a panel that no longer exists.
-        (_a = this._busyEl) === null || _a === void 0 ? void 0 : _a.remove();
-        this._busyEl = null;
         // Disabling a provider must leave its running terminals alive and only
         // drop the tint this panel applied.
         void this._terminals.clearColours();
@@ -400,39 +390,6 @@ export class AssistantSessionsPanel extends Widget {
         loadingSpinner.className =
             'jp-aiAssistants-spinner jp-AiAssistantsPanel-loadingSpinner';
         loading.appendChild(loadingSpinner);
-        // Click-time busy overlay: raised synchronously when a row is opened or
-        // branched, before the terminal probe or the branch request, so the click
-        // never reads as ignored (DEF-PANE-318). It sits on the LAB SHELL, not on
-        // the panel: the feedback belongs in the main working area, where the
-        // launch spinner appears, and a panel that is hidden or scrolled must not
-        // keep it out of sight (DEF-PANE-318-1). It takes no pointer events and no
-        // focus: the context menu that launched a branch stays open until its
-        // command runs, and a focus change would close it.
-        const busy = document.createElement('div');
-        busy.className = 'jp-AiAssistants-busyOverlay';
-        busy.hidden = true;
-        const busySpinner = document.createElement('div');
-        busySpinner.className =
-            'jp-aiAssistants-spinner jp-AiAssistants-busySpinner';
-        busySpinner.setAttribute('aria-hidden', 'true');
-        busy.appendChild(busySpinner);
-        // The action, named in sight: under a reduced-motion preference the ring
-        // is held still, so the label carries the busy state with no animation.
-        // Hidden from assistive technology because the live region below
-        // announces the same words once.
-        const busyLabel = document.createElement('div');
-        busyLabel.className = 'jp-AiAssistants-busyLabel';
-        busyLabel.setAttribute('aria-hidden', 'true');
-        busy.appendChild(busyLabel);
-        // The spinner is decoration; a screen-reader user hears the action
-        // instead. The region sits on the root, always rendered and outside the
-        // overlay and the aria-busy body: a live region created inside a
-        // display:none container, or one whose update lands in an aria-busy
-        // subtree, can be withheld by assistive technology.
-        const busyText = document.createElement('div');
-        busyText.className = 'jp-AiAssistantsPanel-srOnly';
-        busyText.setAttribute('role', 'status');
-        busyText.setAttribute('aria-live', 'polite');
         // Inline error strip - a failed poll reports here and keeps retrying,
         // rather than tearing the panel down or raising a modal that would also
         // interrupt the other providers' panels.
@@ -447,69 +404,10 @@ export class AssistantSessionsPanel extends Widget {
         root.appendChild(error);
         root.appendChild(body);
         root.appendChild(loading);
-        root.appendChild(busyText);
-        // The shell carries the visible feedback; the panel carries the
-        // announcement.
-        this._app.shell.node.appendChild(busy);
         this._bodyEl = body;
         this._loadingEl = loading;
-        this._busyEl = busy;
-        this._busyLabelEl = busyLabel;
-        this._busyTextEl = busyText;
         this._errorEl = error;
     }
-    /** Raise the click-time busy overlay. Each action gets a token, because an
-     * open and a branch can overlap; the overlay clears when the last one ends,
-     * and the label names the newest action still running. */
-    _beginBusy(message) {
-        const token = ++this._busySeq;
-        this._busyMessages.set(token, message);
-        if (this._busyEl) {
-            this._busyEl.hidden = false;
-            this._paintBusyMessage();
-            // The body is what the action changes; the root stays outside the
-            // busy subtree so the live region above is not withheld.
-            if (this._bodyEl) {
-                this._bodyEl.setAttribute('aria-busy', 'true');
-            }
-        }
-        return token;
-    }
-    _endBusy(token) {
-        this._busyMessages.delete(token);
-        if (this._busyMessages.size > 0) {
-            // Another action is still running; neither the visible label nor the
-            // live region may keep naming the one that just ended.
-            this._paintBusyMessage();
-            return;
-        }
-        if (this._busyEl) {
-            this._busyEl.hidden = true;
-            if (this._busyLabelEl) {
-                this._busyLabelEl.textContent = '';
-            }
-            if (this._busyTextEl) {
-                this._busyTextEl.textContent = '';
-            }
-            if (this._bodyEl) {
-                this._bodyEl.removeAttribute('aria-busy');
-            }
-        }
-    }
-    /** Name the newest still-running action in the visible label and the live
-     * region, so neither keeps naming an action that ended. */
-    _paintBusyMessage() {
-        let message = '';
-        for (const active of this._busyMessages.values()) {
-            message = active;
-        }
-        if (this._busyLabelEl) {
-            this._busyLabelEl.textContent = message;
-        }
-        if (this._busyTextEl) {
-            this._busyTextEl.textContent = message;
-        }
-    }
     /** Show / hide the filter input. Hiding also clears the active filter, so
      * the user never returns to an "invisible" filter narrowing the rows. */
     _toggleFilterBar() {
@@ -739,7 +637,8 @@ export class AssistantSessionsPanel extends Widget {
             // to Remove - one Enter on a dialog that has just appeared and the
             // project history is gone (DEF-51). JupyterLab's own file browser sets
             // the same 0 on its delete, for the same reason.
-            defaultButton: 0
+            defaultButton: 0,
+            renderer: dialogRenderer
         });
         if (!confirm.button.accept) {
             return;
@@ -776,7 +675,8 @@ export class AssistantSessionsPanel extends Widget {
                 Dialog.warnButton({ label: this._trans.__('Remove') })
             ],
             // Cancel, as above (DEF-51).
-            defaultButton: 0
+            defaultButton: 0,
+            renderer: dialogRenderer
         });
         if (!confirm.button.accept) {
             return;
@@ -796,7 +696,8 @@ export class AssistantSessionsPanel extends Widget {
         const dialog = new Dialog({
             title: this._trans.__('Clean Up Parallel Sessions'),
             body,
-            buttons: [Dialog.okButton({ label: this._trans.__('Close') })]
+            buttons: [Dialog.okButton({ label: this._trans.__('Close') })],
+            renderer: dialogRenderer
         });
         // Close stays live while the work runs. Hiding it took away the only exit
         // a keyboard user has: the dialog listens for Escape on its own node, it
@@ -854,10 +755,11 @@ export class AssistantSessionsPanel extends Widget {
     }
     async _openSession(session, force, sessionId) {
         // The click's own feedback, raised before the terminal walk and the
-        // launch - both can take seconds (DEF-PANE-318).
-        const busy = this._beginBusy(this._trans.__('Opening conversation'));
+        // launch - both can take seconds (DEF-PANE-318). The launch's title; the
+        // launch joins this dialog through the token.
+        const busy = beginSpinner(this._trans.__('Opening %1', this._descriptor.label), this._trans);
         try {
-            await this._terminals.openSession(session, this._launchMode(force), sessionId);
+            await this._terminals.openSession(session, this._launchMode(force), sessionId, busy);
             // Not awaited: the open has succeeded, and the sync is not part of it.
             fileBrowserMoves = fileBrowserMoves.then(() => this._moveFileBrowserTo(session));
         }
@@ -870,7 +772,7 @@ export class AssistantSessionsPanel extends Widget {
             }
         }
         finally {
-            this._endBusy(busy);
+            endSpinner(busy);
             // Reuse or fresh launch, either way the picture changed. Pull fresh
             // state; a poll tick retries if this one fails.
             void this._fetch().catch(() => undefined);
@@ -1101,20 +1003,21 @@ export class AssistantSessionsPanel extends Widget {
         }
         // Raised on the click: the branch POST mints the fork server-side (for
         // Claude and Codex by running their own CLI) and can take seconds
-        // (DEF-PANE-318).
-        const busy = this._beginBusy(this._trans.__('Branching conversation'));
+        // (DEF-PANE-318). The menu that ran this command closed before running it,
+        // so the dialog taking the focus closes nothing.
+        const busy = beginSpinner(this._trans.__('Branching %1 session', this._descriptor.label), this._trans);
         try {
-            await this._branchByServerCopy(session, undefined, force);
+            await this._branchByServerCopy(session, undefined, force, busy);
         }
         finally {
-            this._endBusy(busy);
+            endSpinner(busy);
         }
     }
     /** The server mints the new id and answers with it before the terminal
      * opens - `server-copy` copies the store entry, `server-native` drives the
      * assistant's own non-interactive fork path - so one refresh surfaces the
-     * branch. */
-    async _branchByServerCopy(session, name, force) {
+     * branch. `spinner` is the click's token, which the launch joins. */
+    async _branchByServerCopy(session, name, force, spinner) {
         // Let the parent's colour settle before the server reads it (DEF-74). The
         // server copies the store entry while minting the fork, so a colour picked
         // on the parent's tab moments earlier - still queued in this store's
@@ -1151,7 +1054,7 @@ export class AssistantSessionsPanel extends Widget {
                 project_path: session.project_path,
                 session_id: fork.session_id,
                 mode: this._launchMode(force)
-            }, fork.session_id);
+            }, fork.session_id, spinner);
         }
         catch (err) {
             if (isResponseStatus(err, 400)) {
@@ -1217,7 +1120,8 @@ export class AssistantSessionsPanel extends Widget {
             title: 'Rename Session',
             label: `Name for this ${this._descriptor.label} conversation`,
             text: session.name_source === 'session' ? session.name : '',
-            placeholder: this._lookupName(session)
+            placeholder: this._lookupName(session),
+            renderer: dialogRenderer
         });
         if (!named.button.accept) {
             return;
@@ -2083,7 +1987,13 @@ export class AssistantSessionsPanel extends Widget {
         });
         this._commands.addCommand(this._cmd('manage-sessions'), {
             label: () => `Manage Sessions... (${this._lastBranches.length})`,
-            execute: () => this._openManagePopup()
+            execute: () => this._openManagePopup('switch')
+        });
+        // The open submenu's copy of the item: same popup, but a row action
+        // launches the conversation rather than making it current.
+        this._commands.addCommand(this._cmd('manage-sessions-open'), {
+            label: () => `Manage Sessions... (${this._lastBranches.length})`,
+            execute: () => this._openManagePopup('open')
         });
         this._commands.addCommand(this._cmd('open-branch'), {
             // Names the mode the launch carries, like Resume, `+` and Branch Session
@@ -2417,10 +2327,10 @@ export class AssistantSessionsPanel extends Widget {
         }
         this._openBranchSubmenu.addItem({ type: 'separator' });
         this._openBranchSubmenu.addItem({
-            command: this._cmd('manage-sessions')
+            command: this._cmd('manage-sessions-open')
         });
     }
-    _openManagePopup() {
+    _openManagePopup(mode) {
         const session = this._activeSession;
         if (!session) {
             return;
@@ -2428,6 +2338,7 @@ export class AssistantSessionsPanel extends Widget {
         const current = this._lastBranchesCurrent || session.session_id;
         showManageSessionsPopup({
             trans: this._trans,
+            mode,
             branches: this._lastBranches,
             current,
             currentName: `${this._lookupName(session)} (${shortSessionId(current, this._descriptor.sessionIdPrefix)})`,

package/lib/core/popup.d.ts

@@ -29,6 +29,10 @@ export declare namespace ManageSessionsPopup {
         formatTime: (epochMs: number) => string;
         /** Provider chip for a branch row, or null. */
         branchBadge?: (branch: IBranch) => HTMLElement | null;
+        /** What a row's action does, inherited from the submenu that opened the
+         * popup: `switch` makes the conversation current, `open` launches it in
+         * its own terminal. */
+        mode: 'switch' | 'open';
         /** Tooltip for one row's Open button. The panel owns it because the launch
          * mode in force is panel state, and every other surface that opens a
          * conversation names it. */

package/lib/core/popup.js

@@ -2,6 +2,7 @@ import { Clipboard, Dialog } from '@jupyterlab/apputils';
 import { nullTranslator } from '@jupyterlab/translation';
 import { copyIcon } from '@jupyterlab/ui-components';
 import { Widget } from '@lumino/widgets';
+import { DialogRenderer } from './dialogs';
 import { branchIcon } from './icons';
 /** Compact copy button for a popup row. `stopPropagation` keeps the click from
  * switching or selecting the row it sits in. */
@@ -17,14 +18,14 @@ function copyButton(sessionId, trans) {
     });
     return btn;
 }
-/** The default dialog renderer with one extra node leading the footer.
+/** The extension's dialog renderer with one extra node leading the footer.
  * JupyterLab builds the footer in the Dialog constructor through
  * `renderer.createFooter`, and `IOptions.renderer` is the public hook for
  * changing it; its only built-in extra, `checkbox`, renders a checkbox, not a
  * button. Leading the footer puts the node before Close in tab order, so the
  * keyboard reaches the list, then Delete, then Close - and the Dialog's own Tab
  * wrap, keyed on its last button, still wraps from Close. */
-class FooterRenderer extends Dialog.Renderer {
+class FooterRenderer extends DialogRenderer {
     constructor(_lead) {
         super();
         this._lead = _lead;
@@ -115,19 +116,32 @@ export function showManageSessionsPopup(options) {
     });
     // Scopes the action-row layout in base.css to this one dialog.
     dialog.addClass('jp-AiAssistantsPanel-branchDialog');
-    // Per-row "Open" launches that conversation in its own terminal and closes
-    // the popup. stopPropagation keeps the click from toggling selection or
-    // switching the row.
-    const openButton = (sessionId) => {
+    // The row action follows the mode the invoking submenu passed: switch makes
+    // the conversation current, open launches it in its own terminal. Both close
+    // the popup first - the action is complete once it runs.
+    const runAction = (sessionId) => {
+        dialog.dispose();
+        if (options.mode === 'switch') {
+            options.onSwitch(sessionId);
+        }
+        else {
+            options.onOpen(sessionId);
+        }
+    };
+    // Per-row action button. stopPropagation keeps the click from toggling
+    // selection or repeating the action through the row's own click handler.
+    const actionButton = (sessionId) => {
         const btn = document.createElement('button');
         btn.type = 'button';
         btn.className = 'jp-AiAssistantsPanel-branchOpen';
-        btn.textContent = 'Open';
-        btn.title = options.openTitle();
+        btn.textContent = options.mode === 'switch' ? 'Switch' : 'Open';
+        btn.title =
+            options.mode === 'switch'
+                ? "Make this the project's current conversation"
+                : options.openTitle();
         btn.addEventListener('click', e => {
             e.stopPropagation();
-            dialog.dispose();
-            options.onOpen(sessionId);
+            runAction(sessionId);
         });
         return btn;
     };
@@ -192,7 +206,11 @@ export function showManageSessionsPopup(options) {
         badge.className = 'jp-AiAssistantsPanel-branchCurrentBadge';
         badge.textContent = 'current';
         currentRow.appendChild(badge);
-        currentRow.appendChild(openButton(options.current));
+        // Switch mode has nothing to switch to on the row that is already current;
+        // open mode can still launch it in a terminal.
+        if (options.mode === 'open') {
+            currentRow.appendChild(actionButton(options.current));
+        }
         currentRow.appendChild(copyButton(options.current, trans));
         list.appendChild(currentRow);
         const matches = visibleMatches();
@@ -270,20 +288,19 @@ export function showManageSessionsPopup(options) {
             time.className = 'jp-AiAssistantsPanel-branchTime';
             time.textContent = options.formatTime(b.file_mtime);
             row.appendChild(time);
-            row.appendChild(openButton(b.session_id));
+            row.appendChild(actionButton(b.session_id));
             row.appendChild(copyButton(b.session_id, trans));
-            // A row click always switches, whatever is selected: the checkbox cell
-            // is the one select target, so a click has one meaning (DEF-PANE-209).
-            const activate = () => {
-                dialog.dispose();
-                options.onSwitch(b.session_id);
-            };
+            // A row click follows the popup's mode, whatever is selected: the
+            // checkbox cell is the one select target, so a click has one meaning
+            // (DEF-PANE-209).
+            const activate = () => runAction(b.session_id);
             row.addEventListener('click', activate);
-            // Switch has no button of its own, so it needs a role and a key route or
-            // it is reachable by mouse only. The affordance sits on the label span,
-            // not the row: the row also hosts a checkbox and the Open/Copy buttons,
-            // and a role="button" wrapping them both swallows their own Enter/Space
-            // and makes them presentational children (ARIA nested-interactive).
+            // The row action also has a button; the label keeps a role and key route
+            // so the row itself stays keyboard-reachable. The affordance sits on the
+            // label span, not the row: the row also hosts a checkbox and the
+            // action/Copy buttons, and a role="button" wrapping them both swallows
+            // their own Enter/Space and makes them presentational children (ARIA
+            // nested-interactive).
             label.setAttribute('role', 'button');
             label.tabIndex = 0;
             label.addEventListener('keydown', e => {

package/lib/core/terminals.d.ts

@@ -1,18 +1,20 @@
 import { JupyterFrontEnd } from '@jupyterlab/application';
-import { Dialog } from '@jupyterlab/apputils';
 import { TranslationBundle } from '@jupyterlab/translation';
 import { ServerConnection } from '@jupyterlab/services';
 import { ITerminalTracker } from '@jupyterlab/terminal';
 import { IColourfulTabs } from 'jupyterlab_colourful_tab_extension';
 import { ColourStore } from './colour';
 import { ILaunchRequest, IProviderDescriptor, ISession, ITerminalProbeResponse } from './types';
-/** Show a modal spinner while a terminal is being launched. The caller
- * dismisses it with `.dispose()` when the launch settles.
- *
- * Hide does not abort the request - it only takes the app-wide scrim away, so
- * a stalled launch cannot leave the user staring at a modal with no exit. If
- * the launch later succeeds the terminal simply appears. */
-export declare function showLaunchSpinner(title: string, trans: TranslationBundle): Dialog<unknown>;
+/** Show the spinner dialog for one action, or retitle the one already up so it
+ * names the newest action. Pass the token to `endSpinner` when the action
+ * settles. Hide disposes the dialog for the actions then running: they stay
+ * hidden and keep no dialog up, and the next action raises a fresh one. The
+ * launch inside a click passes the click's token to `launch()`, so a hidden
+ * click's launch raises nothing. */
+export declare function beginSpinner(title: string, trans: TranslationBundle): number;
+/** End one action. The dialog then names the newest action still running, or
+ * closes with the last one. */
+export declare function endSpinner(token: number): void;
 /**
  * Terminals for one provider: the reuse ladder, the launch call and the tab
  * tint pass.
@@ -40,20 +42,32 @@ export declare class TerminalManager {
      * promise; a different conversation of the same project launches
      * independently, so branches open side by side.
      */
-    openSession(session: ISession, mode: string | undefined, sessionId?: string): Promise<void>;
+    openSession(session: ISession, mode: string | undefined, sessionId?: string, spinner?: number): Promise<void>;
     private _doOpenSession;
     /**
      * Launch a terminal for one request and focus it. The returned widget is
      * tagged with `tagSessionId` in the microcache, so a later click on the row
      * that conversation now belongs to reuses this very terminal.
+     *
+     * `spinner` is the token of the click this launch belongs to. The launch
+     * joins that click's spinner instead of beginning its own, so the user sees
+     * one dialog from the click to the terminal, and a click the user hid stays
+     * hidden.
      */
-    launch(request: ILaunchRequest, tagSessionId?: string): Promise<any>;
+    launch(request: ILaunchRequest, tagSessionId?: string, spinner?: number): Promise<any>;
     /**
      * Bring a terminal tab to the front AND hand it keyboard focus, so typing
      * starts without a second click. `activateById` only reveals the tab; the
      * xterm inside does not reliably take DOM focus when the click came from the
      * sidebar, so the focus call is deferred to the next frame - by then the
      * widget is attached and visible.
+     *
+     * The activation waits for the spinner dialog to close. While the dialog is
+     * up it pulls any focus outside it back to Hide, and on closing it returns
+     * the focus to the element that had it before - so a terminal activated
+     * under it ends up without the keyboard. Closing emits `disposed` before
+     * that return, and the activation the tab then receives is processed after
+     * it, so the terminal is the last to take the focus.
      */
     focus(widget: any): void;
     /** Find an open terminal running exactly this conversation in this project,