jupyterlab_ai_code_assistants_extension 1.2.163 → 1.2.199

package/lib/core/dialogs.d.ts

@@ -2,8 +2,10 @@ 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
+ * footer, and `style/base.css` scopes its dialog rules - no focus rim on a
+ * button focused by the mouse or by a dialog opened with the mouse (keyboard
+ * focus keeps JupyterLab's rim), 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

package/lib/core/dialogs.js

@@ -1,8 +1,10 @@
 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
+ * footer, and `style/base.css` scopes its dialog rules - no focus rim on a
+ * button focused by the mouse or by a dialog opened with the mouse (keyboard
+ * focus keeps JupyterLab's rim), 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

package/lib/core/icons.d.ts

@@ -28,7 +28,11 @@ export declare function providerIcon(name: string, svgstr: string): LabIcon;
  * preset, and each tile under `launcherCard`. This view of `tile` renders the
  * extension's joint icon under the section preset and `tile` everywhere else,
  * so the header carries no vendor's mark while every tile keeps its own
- * (ACC-LNCH-163).
+ * (ACC-LNCH-163). Under `launcherCard` it also adds the class
+ * `jp-AiAssistantsLauncher-tileGlyph`, which `style/base.css` scales to 75%,
+ * so the tile glyph is drawn smaller than JupyterLab's own tile glyphs while
+ * the sidebar tab, panel header and menus keep the standard size
+ * (ACC-LNCH-215).
  *
  * Built the way `LabIcon.bindprops` builds its views - a prototype child of
  * the tile with its own `react` - so `LabIcon.resolve` still recognises it.

package/lib/core/icons.js

@@ -1,4 +1,4 @@
-import { LabIcon } from '@jupyterlab/ui-components';
+import { classes, LabIcon } from '@jupyterlab/ui-components';
 import * as React from 'react';
 // Shared panel chrome icons. Provider icons are NOT here - each provider
 // carries its own SVG on its descriptor and the registry builds the LabIcon
@@ -148,7 +148,11 @@ export function providerIcon(name, svgstr) {
  * preset, and each tile under `launcherCard`. This view of `tile` renders the
  * extension's joint icon under the section preset and `tile` everywhere else,
  * so the header carries no vendor's mark while every tile keeps its own
- * (ACC-LNCH-163).
+ * (ACC-LNCH-163). Under `launcherCard` it also adds the class
+ * `jp-AiAssistantsLauncher-tileGlyph`, which `style/base.css` scales to 75%,
+ * so the tile glyph is drawn smaller than JupyterLab's own tile glyphs while
+ * the sidebar tab, panel header and menus keep the standard size
+ * (ACC-LNCH-215).
  *
  * Built the way `LabIcon.bindprops` builds its views - a prototype child of
  * the tile with its own `react` - so `LabIcon.resolve` still recognises it.
@@ -157,7 +161,13 @@ export function launcherTileIcon(tile) {
     const view = Object.create(tile);
     const react = React.forwardRef((props, ref) => React.createElement(props.stylesheet === 'launcherSection'
         ? assistantsIcon.react
-        : tile.react, { ...props, ref }));
+        : tile.react, {
+        ...props,
+        ...(props.stylesheet === 'launcherCard' && {
+            className: classes(props.className, 'jp-AiAssistantsLauncher-tileGlyph')
+        }),
+        ref
+    }));
     // `react` is readonly on the type; the view shadows the tile's own.
     Object.defineProperty(view, 'react', { value: react });
     return view;

package/lib/core/panel.js

@@ -1057,10 +1057,7 @@ export class AssistantSessionsPanel extends Widget {
             }, fork.session_id, spinner);
         }
         catch (err) {
-            if (isResponseStatus(err, 400)) {
-                Notification.error(`${this._descriptor.label} cannot branch this conversation.`, { autoClose: 4000 });
-            }
-            else if (minted) {
+            if (minted) {
                 // The branch was created and only its terminal was refused - the
                 // launch preflight's 409 carries words for the user. "Could not
                 // branch this session" would be false, and the early return would
@@ -1073,6 +1070,9 @@ export class AssistantSessionsPanel extends Widget {
                 this._notifyLaunchError('Branch created; its terminal did not open', err);
                 await this._fetch().catch(() => undefined);
             }
+            else if (isResponseStatus(err, 400)) {
+                Notification.error(`${this._descriptor.label} cannot branch this conversation.`, { autoClose: 4000 });
+            }
             else {
                 this._showActionError('Could not branch this session - try again.', err);
             }

package/lib/core/popup.js

@@ -50,6 +50,9 @@ export function showManageSessionsPopup(options) {
     // removal is permanent.
     let armed = false;
     let armTimer = 0;
+    // The arming click's event.timeStamp, which the confirm click is measured
+    // against.
+    let armedAt = 0;
     const body = document.createElement('div');
     body.className = 'jp-AiAssistantsPanel-branchPopup';
     const search = document.createElement('input');
@@ -348,10 +351,17 @@ export function showManageSessionsPopup(options) {
             list.removeAttribute('aria-busy');
         }
     };
-    deleteBtn.addEventListener('click', () => {
+    deleteBtn.addEventListener('click', event => {
         if (deleting || selected.size === 0) {
             return;
         }
+        // The second click of a double-click is not a confirmation (DEF-PANE-336):
+        // a multi-click within 600 ms of arming is ignored. A later click confirms
+        // whatever its detail - the OS double-click interval can be longer than
+        // the user's pause, and the click would be dropped (DEF-PANE-338).
+        if (armed && event.detail > 1 && event.timeStamp - armedAt < 600) {
+            return;
+        }
         // No confirmation DIALOG here: a second Lumino dialog stacked on this popup
         // renders detached. The deletion confirms in the footer itself - the first
         // click arms the button, the second executes, and any selection change or
@@ -360,6 +370,7 @@ export function showManageSessionsPopup(options) {
         // refused move may remove the conversation permanently or leave it.
         if (!armed) {
             armed = true;
+            armedAt = event.timeStamp;
             window.clearTimeout(armTimer);
             armTimer = window.setTimeout(() => {
                 disarm();

package/lib/core/terminals.d.ts

@@ -20,9 +20,10 @@ export declare function endSpinner(token: number): void;
  * tint pass.
  *
  * Split out of the panel because none of it is presentation - it is process
- * identity. The panel asks for a conversation and gets a focused terminal
- * running exactly that conversation, or a fresh one; nothing in here knows
- * about sections, filters or menus.
+ * identity. The panel asks for a conversation and gets a terminal running
+ * exactly that conversation, or a fresh one, focused unless the user hid the
+ * action's spinner dialog; nothing in here knows about sections, filters or
+ * menus.
  */
 export declare class TerminalManager {
     constructor(options: TerminalManager.IOptions);
@@ -52,9 +53,13 @@ export declare class TerminalManager {
      * `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.
+     * hidden and its terminal opens behind the current tab.
      */
     launch(request: ILaunchRequest, tagSessionId?: string, spinner?: number): Promise<any>;
+    /** Show the current widget's tab again. Opening a terminal selects its tab,
+     * so for a hidden action the tab the user was on goes back in front
+     * (DEF-PANE-339). */
+    private _showCurrentTab;
     /**
      * 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
@@ -68,8 +73,12 @@ export declare class TerminalManager {
      * 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.
+     *
+     * `spinner` is the token of the action that asked. When the user hid that
+     * action's dialog the terminal is left where it is, and so is a terminal
+     * waiting for the dialog the user then hides (DEF-PANE-339).
      */
-    focus(widget: any): void;
+    focus(widget: any, spinner?: number): void;
     /** Find an open terminal running exactly this conversation in this project,
      * or null.
      *

package/lib/core/terminals.js

@@ -75,7 +75,8 @@ function titleSpinner(dialog, title) {
  *
  * Hide does not abort the request - it only takes the app-wide scrim away, so
  * a stalled action cannot leave the user staring at a modal with no exit. If
- * the action later succeeds the terminal simply appears. */
+ * the action later succeeds the terminal opens as a tab behind the current
+ * one (DEF-PANE-339). */
 function showLaunchSpinner(title, trans) {
     const body = new Widget();
     body.node.className = 'jp-AiAssistantsPanel-launchOverlay';
@@ -87,10 +88,13 @@ function showLaunchSpinner(title, trans) {
         title,
         body,
         // `Hide`, not `Cancel`. The button takes the scrim away and nothing else -
-        // the request is already on the wire and the terminal will still open and
-        // take focus. A button named Cancel that does not cancel is worse than no
-        // button.
+        // the request is already on the wire and the terminal will still open, as
+        // a tab behind the current one that does not take the keyboard. A button
+        // named Cancel that does not cancel is worse than no button.
         buttons: [Dialog.okButton({ label: trans.__('Hide') })],
+        // Hide is the only exit: the second click of a double-click on the row
+        // lands on the backdrop, and that is not a choice to hide (DEF-PANE-340).
+        hasClose: false,
         renderer: spinnerRenderer
     });
     // Scopes the compact layout in base.css to this one dialog.
@@ -110,6 +114,12 @@ function showLaunchSpinner(title, trans) {
 let spinnerDialog = null;
 let spinnerSeq = 0;
 const spinnerTitles = new Map();
+/** Whether the user hid the dialog of `token`, an action still running. Hide
+ * disposes the dialog, and an action begun after it raises a fresh dialog that
+ * does not stand for the hidden one (DEF-PANE-339). */
+function spinnerHidden(token) {
+    return (!spinnerDialog || spinnerDialog.isDisposed || !spinnerTitles.has(token));
+}
 /** 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
@@ -146,9 +156,10 @@ export function endSpinner(token) {
  * tint pass.
  *
  * Split out of the panel because none of it is presentation - it is process
- * identity. The panel asks for a conversation and gets a focused terminal
- * running exactly that conversation, or a fresh one; nothing in here knows
- * about sections, filters or menus.
+ * identity. The panel asks for a conversation and gets a terminal running
+ * exactly that conversation, or a fresh one, focused unless the user hid the
+ * action's spinner dialog; nothing in here knows about sections, filters or
+ * menus.
  */
 export class TerminalManager {
     constructor(options) {
@@ -259,7 +270,7 @@ export class TerminalManager {
         // when it carries the wanted conversation.
         const cached = this._byProject.get(session.project_path);
         if (cached && !cached.widget.isDisposed && cached.sessionId === wanted) {
-            this.focus(cached.widget);
+            this.focus(cached.widget, spinner);
             return;
         }
         // 2. Walk every live terminal, asking the server what each is running in
@@ -273,7 +284,7 @@ export class TerminalManager {
                 sessionId: (_a = found.runningId) !== null && _a !== void 0 ? _a : undefined
             });
             this._wireDisposal(session.project_path, found.widget);
-            this.focus(found.widget);
+            this.focus(found.widget, spinner);
             return;
         }
         // 3. Fresh launch. The server picks the verb (resume, attach, bare) at
@@ -294,7 +305,7 @@ export class TerminalManager {
      * `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.
+     * hidden and its terminal opens behind the current tab.
      */
     async launch(request, tagSessionId, spinner) {
         const own = spinner === undefined
@@ -302,16 +313,43 @@ export class TerminalManager {
             : undefined;
         try {
             const launched = await requestProvider(this._descriptor.id, 'launch', this._serverSettings, { method: 'POST', body: JSON.stringify(request) });
-            const widget = await this._app.commands.execute('terminal:open', {
-                name: launched.terminal_name
-            });
+            const token = spinner !== null && spinner !== void 0 ? spinner : own;
+            const name = launched.terminal_name;
+            // `terminal:open` shows the new terminal's tab and moves the focus into
+            // it before it returns. When the user has hidden this action's dialog,
+            // that focus is stopped before the shell sees it, as JupyterLab's Dialog
+            // stops focus that leaves it, so the user's widget stays the current one.
+            // The focus goes back to the element it left once the user's tab is
+            // shown again (DEF-PANE-339).
+            let left = null;
+            const keep = (event) => {
+                const target = event.target;
+                if (spinnerHidden(token) &&
+                    this._liveTerminals().some(w => { var _a, _b; return ((_b = (_a = w.content) === null || _a === void 0 ? void 0 : _a.session) === null || _b === void 0 ? void 0 : _b.name) === name && w.node.contains(target); })) {
+                    event.stopPropagation();
+                    left = event.relatedTarget;
+                    target.blur();
+                }
+            };
+            document.addEventListener('focus', keep, true);
+            let widget;
+            try {
+                widget = await this._app.commands.execute('terminal:open', { name });
+            }
+            finally {
+                document.removeEventListener('focus', keep, true);
+            }
+            if (spinnerHidden(token)) {
+                this._showCurrentTab();
+                left === null || left === void 0 ? void 0 : left.focus();
+            }
             if (widget === null || widget === void 0 ? void 0 : widget.id) {
                 this._byProject.set(request.project_path, {
                     widget,
                     sessionId: tagSessionId
                 });
                 this._wireDisposal(request.project_path, widget);
-                this.focus(widget);
+                this.focus(widget, token);
             }
             return widget !== null && widget !== void 0 ? widget : null;
         }
@@ -321,6 +359,17 @@ export class TerminalManager {
             }
         }
     }
+    /** Show the current widget's tab again. Opening a terminal selects its tab,
+     * so for a hidden action the tab the user was on goes back in front
+     * (DEF-PANE-339). */
+    _showCurrentTab() {
+        const shell = this._app.shell;
+        const current = shell.currentWidget;
+        const bar = current && shell.getMainAreaTabBar(current);
+        if (bar) {
+            bar.currentTitle = current.title;
+        }
+    }
     /**
      * 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
@@ -334,13 +383,31 @@ export class TerminalManager {
      * 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.
+     *
+     * `spinner` is the token of the action that asked. When the user hid that
+     * action's dialog the terminal is left where it is, and so is a terminal
+     * waiting for the dialog the user then hides (DEF-PANE-339).
      */
-    focus(widget) {
+    focus(widget, spinner) {
         if (!widget || widget.isDisposed) {
             return;
         }
+        if (spinner !== undefined && spinnerHidden(spinner)) {
+            return;
+        }
         if (spinnerDialog && !spinnerDialog.isDisposed) {
-            spinnerDialog.disposed.connect(() => this.focus(widget));
+            spinnerDialog.disposed.connect(() => {
+                // The dialog closes on its own only with its last action. Closed with
+                // an action still running, the user hid it: the terminal is not
+                // activated, and its tab, shown behind the dialog, goes back behind
+                // the user's tab.
+                if (spinnerTitles.size > 0) {
+                    this._showCurrentTab();
+                }
+                else {
+                    this.focus(widget);
+                }
+            });
             return;
         }
         this._app.shell.activateById(widget.id);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "jupyterlab_ai_code_assistants_extension",
-    "version": "1.2.163",
+    "version": "1.2.199",
     "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",
@@ -169,5 +169,8 @@
             "selector-no-vendor-prefix": null,
             "value-no-vendor-prefix": null
         }
+    },
+    "allowScripts": {
+        "@fortawesome/fontawesome-free": true
     }
 }

package/src/__tests__/icon-size.spec.ts

@@ -3,8 +3,10 @@
  * icons (DEF-PANE-332).
  *
  * The Launcher card, the sidebar tab and the menus draw every icon in one box
- * size, so how big a glyph looks there is fixed by the SVG alone: the share of
- * the viewBox its drawn paths cover. The reference is measured from
+ * size, so how big a glyph looks there is fixed by the SVG: the share of the
+ * viewBox its drawn paths cover. In the Launcher card the assistant svg is then
+ * scaled to 0.75 (ACC-LNCH-215, style/base.css), so the tile glyph is three
+ * quarters of that share. The reference is measured from
  * JupyterLab's terminal icon, the Terminal card of the same Launcher, rather
  * than written down, and each provider glyph is measured the same way.
  */

package/src/__tests__/launcher-icon.spec.ts

@@ -30,8 +30,10 @@ import { PROVIDERS } from '../providers';
 
 type Preset = 'launcherSection' | 'launcherCard';
 
-function markup(icon: LabIcon, stylesheet: Preset): string {
-  return renderToStaticMarkup(React.createElement(icon.react, { stylesheet }));
+function markup(icon: LabIcon, stylesheet: Preset, className?: string): string {
+  return renderToStaticMarkup(
+    React.createElement(icon.react, { stylesheet, className })
+  );
 }
 
 const tiles = PROVIDERS.map(module => [
@@ -55,7 +57,11 @@ describe('ACC-LNCH-163 - the section header draws the joint icon', () => {
 
   it.each(tiles)('%s: its own glyph on the tile', (_id, tile) => {
     const view = launcherTileIcon(tile);
-    expect(markup(view, 'launcherCard')).toBe(markup(tile, 'launcherCard'));
+    // The tile's glyph carries the class style/base.css scales to 75%
+    // (ACC-LNCH-215).
+    expect(markup(view, 'launcherCard')).toBe(
+      markup(tile, 'launcherCard', 'jp-AiAssistantsLauncher-tileGlyph')
+    );
     expect(markup(view, 'launcherCard')).not.toBe(
       markup(assistantsIcon, 'launcherCard')
     );

package/src/__tests__/panel.spec.ts

@@ -585,83 +585,92 @@ describe('click-time spinner dialog (DEF-PANE-318, DEF-PANE-327-BUSY-MODAL-1)',
 });
 
 describe('a branch whose terminal launch was refused after the mint', () => {
-  it('says the branch was created and still lists it when the launch is refused', async () => {
-    // The DeepSeek preflight refuses the follow-up launch with a 409 whose
-    // body is words, but by then the branch POST has already returned 200 with
-    // the minted id - the row exists server-side. The user is told that, and
-    // the refresh that surfaces the row still runs; "Could not branch this
-    // session" would report the whole action as failed and leave the branch
-    // invisible until the next poll.
-    const target = makePanel({ ...DESCRIPTOR, forkStrategy: 'server-copy' });
-    const parent = session({ name: 'analysis', name_source: 'session' });
-    const child = session({
-      name: 'analysis_1',
-      session_id: 'child',
-      encoded_path: 'enc-child'
-    });
-    const refusal =
-      'the TUI profile is not mounted; run dsh plugin --profile tui add @deepseek-harness-tui/dsh-tui';
-    (target as any)._terminals.launch = jest
-      .fn()
-      .mockRejectedValue(
-        Object.assign(new Error(refusal), { response: { status: 409 } })
+  it.each<[number, string]>([
+    [
+      409,
+      'the TUI profile is not mounted; run dsh plugin --profile tui add @deepseek-harness-tui/dsh-tui'
+    ],
+    // DEF-PANE-337: the launch preflight's 400 for a project folder that is
+    // gone is not the branch POST's 400, and must not read as one.
+    [400, 'invalid_project_path']
+  ])(
+    'says the branch was created and still lists it when the launch is refused with %i',
+    async (status, refusal) => {
+      // The DeepSeek preflight refuses the follow-up launch with a 409 whose
+      // body is words, but by then the branch POST has already returned 200 with
+      // the minted id - the row exists server-side. The user is told that, and
+      // the refresh that surfaces the row still runs; "Could not branch this
+      // session" would report the whole action as failed and leave the branch
+      // invisible until the next poll.
+      const target = makePanel({ ...DESCRIPTOR, forkStrategy: 'server-copy' });
+      const parent = session({ name: 'analysis', name_source: 'session' });
+      const child = session({
+        name: 'analysis_1',
+        session_id: 'child',
+        encoded_path: 'enc-child'
+      });
+      (target as any)._terminals.launch = jest
+        .fn()
+        .mockRejectedValue(
+          Object.assign(new Error(refusal), { response: { status } })
+        );
+      (target as any)._activeSession = parent;
+      request.mockImplementation((_id: string, path: string) =>
+        Promise.resolve(
+          path === 'branch'
+            ? { session_id: 'child' }
+            : path === 'sessions'
+              ? { sessions: [parent, child] }
+              : {}
+        )
       );
-    (target as any)._activeSession = parent;
-    request.mockImplementation((_id: string, path: string) =>
-      Promise.resolve(
-        path === 'branch'
-          ? { session_id: 'child' }
-          : path === 'sessions'
-            ? { sessions: [parent, child] }
-            : {}
-      )
-    );
-    const errored = jest
-      .spyOn(Notification, 'error')
-      .mockImplementation(() => '');
-    try {
-      await (target as any)._branchSession();
+      const errored = jest
+        .spyOn(Notification, 'error')
+        .mockImplementation(() => '');
+      try {
+        await (target as any)._branchSession();
 
-      // The refused launch still closes the click-time spinner dialog.
-      await flush();
-      expect(document.querySelector('.jp-Dialog')).toBeNull();
+        // The refused launch still closes the click-time spinner dialog.
+        await flush();
+        expect(document.querySelector('.jp-Dialog')).toBeNull();
 
-      // What the user is told: the branch was created, its terminal did not
-      // open, and the refusal's own words - neither sentence that blames the
-      // branch itself.
-      expect(errored).toHaveBeenCalledTimes(1);
-      const told = String(errored.mock.calls[0][0]);
-      expect(told).toContain('Branch created; its terminal did not open');
-      expect(told).toContain(refusal);
-      expect(told).not.toContain('cannot branch this conversation');
-      expect(told).not.toContain('Could not branch this session');
-
-      // The toast budget, by arithmetic rather than by eye: JupyterLab shows
-      // a toast's first 140 characters and clips the rest, and a store may
-      // raise a message of up to 97 (tests/test_provider_stores.py holds the
-      // DeepSeek refusal to that), so the panel's copy plus ": " gets
-      // 140 - 2 - 97 = 41 characters. This reddens when a reworded copy
-      // grows past the budget - the 55-character "The branch was created,
-      // but its terminal could not open" only showed the cut in a browser
-      // toast, with the store's command sliced mid-name.
-      const copy = told.slice(0, told.indexOf(refusal) - 2);
-      expect(copy.length + 2 + 97).toBeLessThanOrEqual(140);
-
-      // The list was re-read, so the new branch is on screen rather than
-      // waiting for the next poll.
-      expect(
-        (target as any)._sessions.map((s: ISession) => s.session_id)
-      ).toContain('child');
-      const names = Array.from(
-        target.node.querySelectorAll('.jp-AiAssistantsPanel-nameText')
-      ).map(node => node.textContent);
-      expect(names).toContain('analysis_1');
-    } finally {
-      errored.mockRestore();
-      target.dispose();
-      request.mockImplementation(() => Promise.resolve({}));
+        // What the user is told: the branch was created, its terminal did not
+        // open, and the refusal's own words - neither sentence that blames the
+        // branch itself.
+        expect(errored).toHaveBeenCalledTimes(1);
+        const told = String(errored.mock.calls[0][0]);
+        expect(told).toContain('Branch created; its terminal did not open');
+        expect(told).toContain(refusal);
+        expect(told).not.toContain('cannot branch this conversation');
+        expect(told).not.toContain('Could not branch this session');
+
+        // The toast budget, by arithmetic rather than by eye: JupyterLab shows
+        // a toast's first 140 characters and clips the rest, and a store may
+        // raise a message of up to 97 (tests/test_provider_stores.py holds the
+        // DeepSeek refusal to that), so the panel's copy plus ": " gets
+        // 140 - 2 - 97 = 41 characters. This reddens when a reworded copy
+        // grows past the budget - the 55-character "The branch was created,
+        // but its terminal could not open" only showed the cut in a browser
+        // toast, with the store's command sliced mid-name.
+        const copy = told.slice(0, told.indexOf(refusal) - 2);
+        expect(copy.length + 2 + 97).toBeLessThanOrEqual(140);
+
+        // The list was re-read, so the new branch is on screen rather than
+        // waiting for the next poll.
+        expect(
+          (target as any)._sessions.map((s: ISession) => s.session_id)
+        ).toContain('child');
+        const names = Array.from(
+          target.node.querySelectorAll('.jp-AiAssistantsPanel-nameText')
+        ).map(node => node.textContent);
+        expect(names).toContain('analysis_1');
+      } finally {
+        errored.mockRestore();
+        target.dispose();
+        request.mockImplementation(() => Promise.resolve({}));
+      }
     }
-  });
+  );
 });
 
 describe('DEF-46 - the row tooltip names only a mode the row launches with', () => {

package/src/__tests__/popup.spec.ts

@@ -276,4 +276,51 @@ describe('Manage Sessions popup permanent Delete', () => {
     expect(del.textContent).toBe('Delete (1)');
     expect(onDelete).not.toHaveBeenCalled();
   });
+
+  it('DEF-PANE-336 - a double-click arms and does not delete', async () => {
+    checkbox(rows()[1]).click();
+    const del = deleteButton();
+    const click = (detail: number): void => {
+      del.dispatchEvent(new MouseEvent('click', { bubbles: true, detail }));
+    };
+
+    // The two clicks a double-click dispatches: detail 1, then detail 2.
+    click(1);
+    click(2);
+    await Promise.resolve();
+    expect(onDelete).not.toHaveBeenCalled();
+    expect(del.classList.contains('jp-mod-armed')).toBe(true);
+
+    // A separate click confirms.
+    click(1);
+    await Promise.resolve();
+    expect(onDelete).toHaveBeenCalledTimes(1);
+    expect(onDelete).toHaveBeenCalledWith([FIRST]);
+  });
+
+  it('DEF-PANE-338-CONFIRM-WINDOW - a multi-click 600 ms after arming confirms', async () => {
+    checkbox(rows()[1]).click();
+    const del = deleteButton();
+    // The arm window is measured on the event clock, so each click carries
+    // its own timeStamp.
+    const click = (detail: number, timeStamp: number): void => {
+      const event = new MouseEvent('click', { bubbles: true, detail });
+      Object.defineProperty(event, 'timeStamp', { value: timeStamp });
+      del.dispatchEvent(event);
+    };
+
+    // Within 600 ms of arming, a detail-2 click is the second click of a
+    // double-click.
+    click(1, 1000);
+    click(2, 1500);
+    await Promise.resolve();
+    expect(onDelete).not.toHaveBeenCalled();
+    expect(del.classList.contains('jp-mod-armed')).toBe(true);
+
+    // Past 600 ms, a click the OS still counts into the double-click confirms.
+    click(2, 1700);
+    await Promise.resolve();
+    expect(onDelete).toHaveBeenCalledTimes(1);
+    expect(onDelete).toHaveBeenCalledWith([FIRST]);
+  });
 });

package/src/__tests__/terminals.spec.ts

@@ -373,4 +373,120 @@ describe('one spinner dialog (DEF-PANE-327-BUSY-MODAL-1)', () => {
       endSpinner(hidden);
     }
   });
+
+  it('activates a terminal waiting on the dialog only when the dialog closes on its own (DEF-PANE-339)', async () => {
+    manager = makeManager();
+    const activated = jest.spyOn((manager as any)._app.shell, 'activateById');
+
+    // Another action keeps the dialog up after this launch has ended, so its
+    // terminal waits for the dialog to close. The user hides the dialog.
+    const other = beginSpinner('Branching Testbed session', trans);
+    try {
+      await manager.launch(
+        { project_path: PROJECT, session_id: CURRENT },
+        CURRENT
+      );
+      await flush();
+      expect(spinners()).toHaveLength(1);
+      spinners()[0]
+        .querySelector<HTMLElement>('.jp-Dialog-footer .jp-Dialog-button')!
+        .click();
+      await flush();
+      expect(spinners()).toHaveLength(0);
+      expect(activated).not.toHaveBeenCalled();
+    } finally {
+      endSpinner(other);
+    }
+
+    // Without Hide the dialog closes with the last action and the terminal
+    // is activated.
+    const next = beginSpinner('Branching Testbed session', trans);
+    let opened: any;
+    try {
+      opened = await manager.launch(
+        { project_path: PROJECT, session_id: CURRENT },
+        CURRENT
+      );
+      await flush();
+      expect(activated).not.toHaveBeenCalled();
+    } finally {
+      endSpinner(next);
+    }
+    await flush();
+    expect(activated).toHaveBeenCalledWith(opened.id);
+  });
+
+  it("leaves a hidden action's terminal alone when a later action's dialog closes (DEF-PANE-339)", async () => {
+    manager = makeManager();
+    const activated = jest.spyOn((manager as any)._app.shell, 'activateById');
+
+    // The user hides the dialog, then a later action raises a fresh one that
+    // stands for the later action alone.
+    const hidden = beginSpinner('Opening Testbed', trans);
+    let later: number | undefined;
+    try {
+      await flush();
+      spinners()[0]
+        .querySelector<HTMLElement>('.jp-Dialog-footer .jp-Dialog-button')!
+        .click();
+      later = beginSpinner('Branching Testbed session', trans);
+      await flush();
+      expect(spinners()).toHaveLength(1);
+
+      // The hidden action's terminal opens while the later dialog is up, and
+      // that dialog then closes on its own: the terminal is not activated.
+      await manager.launch(
+        { project_path: PROJECT, session_id: CURRENT },
+        CURRENT,
+        hidden
+      );
+      endSpinner(later);
+      await flush();
+      expect(spinners()).toHaveLength(0);
+      expect(activated).not.toHaveBeenCalled();
+    } finally {
+      if (later !== undefined) {
+        endSpinner(later);
+      }
+      endSpinner(hidden);
+    }
+  });
+
+  it('keeps the dialog up through the second click of a double-click, and the terminal then takes the keyboard (DEF-PANE-340)', async () => {
+    manager = makeManager();
+    const activated = jest.spyOn((manager as any)._app.shell, 'activateById');
+    const answer = request.getMockImplementation()!;
+    let release!: () => void;
+    const held = new Promise<void>(resolve => {
+      release = resolve;
+    });
+    request.mockImplementation(((...args: Parameters<typeof answer>) =>
+      args[1] === 'launch'
+        ? held.then(() => answer(...args))
+        : answer(...args)) as any);
+    const call = manager.launch(
+      { project_path: PROJECT, session_id: CURRENT },
+      CURRENT
+    );
+    let opened: any;
+    try {
+      await flush();
+      expect(spinners()).toHaveLength(1);
+      // The second click of a double-click on the row lands on the backdrop,
+      // outside the dialog's content.
+      for (const type of ['mousedown', 'click']) {
+        spinners()[0].dispatchEvent(
+          new MouseEvent(type, { bubbles: true, cancelable: true, detail: 2 })
+        );
+      }
+      await flush();
+      expect(spinners()).toHaveLength(1);
+    } finally {
+      release();
+      opened = await call;
+    }
+    await flush();
+    expect(spinners()).toHaveLength(0);
+    expect(activated).toHaveBeenCalledWith(opened.id);
+  });
 });

package/src/core/dialogs.ts

@@ -3,8 +3,10 @@ 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
+ * footer, and `style/base.css` scopes its dialog rules - no focus rim on a
+ * button focused by the mouse or by a dialog opened with the mouse (keyboard
+ * focus keeps JupyterLab's rim), 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

package/src/core/icons.ts

@@ -1,4 +1,4 @@
-import { LabIcon } from '@jupyterlab/ui-components';
+import { classes, LabIcon } from '@jupyterlab/ui-components';
 import * as React from 'react';
 
 // Shared panel chrome icons. Provider icons are NOT here - each provider
@@ -175,7 +175,11 @@ export function providerIcon(name: string, svgstr: string): LabIcon {
  * preset, and each tile under `launcherCard`. This view of `tile` renders the
  * extension's joint icon under the section preset and `tile` everywhere else,
  * so the header carries no vendor's mark while every tile keeps its own
- * (ACC-LNCH-163).
+ * (ACC-LNCH-163). Under `launcherCard` it also adds the class
+ * `jp-AiAssistantsLauncher-tileGlyph`, which `style/base.css` scales to 75%,
+ * so the tile glyph is drawn smaller than JupyterLab's own tile glyphs while
+ * the sidebar tab, panel header and menus keep the standard size
+ * (ACC-LNCH-215).
  *
  * Built the way `LabIcon.bindprops` builds its views - a prototype child of
  * the tile with its own `react` - so `LabIcon.resolve` still recognises it.
@@ -188,7 +192,16 @@ export function launcherTileIcon(tile: LabIcon): LabIcon {
         props.stylesheet === 'launcherSection'
           ? assistantsIcon.react
           : tile.react,
-        { ...props, ref }
+        {
+          ...props,
+          ...(props.stylesheet === 'launcherCard' && {
+            className: classes(
+              props.className,
+              'jp-AiAssistantsLauncher-tileGlyph'
+            )
+          }),
+          ref
+        }
       )
   );
   // `react` is readonly on the type; the view shadows the tile's own.

package/src/core/panel.ts

@@ -1254,12 +1254,7 @@ export class AssistantSessionsPanel extends Widget {
         spinner
       );
     } catch (err) {
-      if (isResponseStatus(err, 400)) {
-        Notification.error(
-          `${this._descriptor.label} cannot branch this conversation.`,
-          { autoClose: 4000 }
-        );
-      } else if (minted) {
+      if (minted) {
         // The branch was created and only its terminal was refused - the
         // launch preflight's 409 carries words for the user. "Could not
         // branch this session" would be false, and the early return would
@@ -1274,6 +1269,11 @@ export class AssistantSessionsPanel extends Widget {
           err
         );
         await this._fetch().catch(() => undefined);
+      } else if (isResponseStatus(err, 400)) {
+        Notification.error(
+          `${this._descriptor.label} cannot branch this conversation.`,
+          { autoClose: 4000 }
+        );
       } else {
         this._showActionError(
           'Could not branch this session - try again.',

package/src/core/popup.ts

@@ -116,6 +116,9 @@ export function showManageSessionsPopup(
   // removal is permanent.
   let armed = false;
   let armTimer = 0;
+  // The arming click's event.timeStamp, which the confirm click is measured
+  // against.
+  let armedAt = 0;
 
   const body = document.createElement('div');
   body.className = 'jp-AiAssistantsPanel-branchPopup';
@@ -437,10 +440,17 @@ export function showManageSessionsPopup(
     }
   };
 
-  deleteBtn.addEventListener('click', () => {
+  deleteBtn.addEventListener('click', event => {
     if (deleting || selected.size === 0) {
       return;
     }
+    // The second click of a double-click is not a confirmation (DEF-PANE-336):
+    // a multi-click within 600 ms of arming is ignored. A later click confirms
+    // whatever its detail - the OS double-click interval can be longer than
+    // the user's pause, and the click would be dropped (DEF-PANE-338).
+    if (armed && event.detail > 1 && event.timeStamp - armedAt < 600) {
+      return;
+    }
     // No confirmation DIALOG here: a second Lumino dialog stacked on this popup
     // renders detached. The deletion confirms in the footer itself - the first
     // click arms the button, the second executes, and any selection change or
@@ -449,6 +459,7 @@ export function showManageSessionsPopup(
     // refused move may remove the conversation permanently or leave it.
     if (!armed) {
       armed = true;
+      armedAt = event.timeStamp;
       window.clearTimeout(armTimer);
       armTimer = window.setTimeout(() => {
         disarm();

package/src/core/terminals.ts

@@ -1,4 +1,4 @@
-import { JupyterFrontEnd } from '@jupyterlab/application';
+import { ILabShell, JupyterFrontEnd } from '@jupyterlab/application';
 import { Dialog, Notification } from '@jupyterlab/apputils';
 import { TranslationBundle, nullTranslator } from '@jupyterlab/translation';
 import { ServerConnection } from '@jupyterlab/services';
@@ -103,7 +103,8 @@ function titleSpinner(dialog: Dialog<unknown>, title: string): void {
  *
  * Hide does not abort the request - it only takes the app-wide scrim away, so
  * a stalled action cannot leave the user staring at a modal with no exit. If
- * the action later succeeds the terminal simply appears. */
+ * the action later succeeds the terminal opens as a tab behind the current
+ * one (DEF-PANE-339). */
 function showLaunchSpinner(
   title: string,
   trans: TranslationBundle
@@ -120,10 +121,13 @@ function showLaunchSpinner(
     title,
     body,
     // `Hide`, not `Cancel`. The button takes the scrim away and nothing else -
-    // the request is already on the wire and the terminal will still open and
-    // take focus. A button named Cancel that does not cancel is worse than no
-    // button.
+    // the request is already on the wire and the terminal will still open, as
+    // a tab behind the current one that does not take the keyboard. A button
+    // named Cancel that does not cancel is worse than no button.
     buttons: [Dialog.okButton({ label: trans.__('Hide') })],
+    // Hide is the only exit: the second click of a double-click on the row
+    // lands on the backdrop, and that is not a choice to hide (DEF-PANE-340).
+    hasClose: false,
     renderer: spinnerRenderer
   });
   // Scopes the compact layout in base.css to this one dialog.
@@ -145,6 +149,15 @@ let spinnerDialog: Dialog<unknown> | null = null;
 let spinnerSeq = 0;
 const spinnerTitles = new Map<number, string>();
 
+/** Whether the user hid the dialog of `token`, an action still running. Hide
+ * disposes the dialog, and an action begun after it raises a fresh dialog that
+ * does not stand for the hidden one (DEF-PANE-339). */
+function spinnerHidden(token: number): boolean {
+  return (
+    !spinnerDialog || spinnerDialog.isDisposed || !spinnerTitles.has(token)
+  );
+}
+
 /** 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
@@ -182,9 +195,10 @@ export function endSpinner(token: number): void {
  * tint pass.
  *
  * Split out of the panel because none of it is presentation - it is process
- * identity. The panel asks for a conversation and gets a focused terminal
- * running exactly that conversation, or a fresh one; nothing in here knows
- * about sections, filters or menus.
+ * identity. The panel asks for a conversation and gets a terminal running
+ * exactly that conversation, or a fresh one, focused unless the user hid the
+ * action's spinner dialog; nothing in here knows about sections, filters or
+ * menus.
  */
 export class TerminalManager {
   constructor(options: TerminalManager.IOptions) {
@@ -274,7 +288,7 @@ export class TerminalManager {
     // when it carries the wanted conversation.
     const cached = this._byProject.get(session.project_path);
     if (cached && !cached.widget.isDisposed && cached.sessionId === wanted) {
-      this.focus(cached.widget);
+      this.focus(cached.widget, spinner);
       return;
     }
 
@@ -289,7 +303,7 @@ export class TerminalManager {
         sessionId: found.runningId ?? undefined
       });
       this._wireDisposal(session.project_path, found.widget);
-      this.focus(found.widget);
+      this.focus(found.widget, spinner);
       return;
     }
 
@@ -316,7 +330,7 @@ export class TerminalManager {
    * `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.
+   * hidden and its terminal opens behind the current tab.
    */
   async launch(
     request: ILaunchRequest,
@@ -337,16 +351,46 @@ export class TerminalManager {
         this._serverSettings,
         { method: 'POST', body: JSON.stringify(request) }
       );
-      const widget: any = await this._app.commands.execute('terminal:open', {
-        name: launched.terminal_name
-      });
+      const token = spinner ?? own!;
+      const name = launched.terminal_name;
+      // `terminal:open` shows the new terminal's tab and moves the focus into
+      // it before it returns. When the user has hidden this action's dialog,
+      // that focus is stopped before the shell sees it, as JupyterLab's Dialog
+      // stops focus that leaves it, so the user's widget stays the current one.
+      // The focus goes back to the element it left once the user's tab is
+      // shown again (DEF-PANE-339).
+      let left = null as HTMLElement | null;
+      const keep = (event: FocusEvent): void => {
+        const target = event.target as HTMLElement;
+        if (
+          spinnerHidden(token) &&
+          this._liveTerminals().some(
+            w => w.content?.session?.name === name && w.node.contains(target)
+          )
+        ) {
+          event.stopPropagation();
+          left = event.relatedTarget as HTMLElement | null;
+          target.blur();
+        }
+      };
+      document.addEventListener('focus', keep, true);
+      let widget: any;
+      try {
+        widget = await this._app.commands.execute('terminal:open', { name });
+      } finally {
+        document.removeEventListener('focus', keep, true);
+      }
+      if (spinnerHidden(token)) {
+        this._showCurrentTab();
+        left?.focus();
+      }
       if (widget?.id) {
         this._byProject.set(request.project_path, {
           widget,
           sessionId: tagSessionId
         });
         this._wireDisposal(request.project_path, widget);
-        this.focus(widget);
+        this.focus(widget, token);
       }
       return widget ?? null;
     } finally {
@@ -356,6 +400,18 @@ export class TerminalManager {
     }
   }
 
+  /** Show the current widget's tab again. Opening a terminal selects its tab,
+   * so for a hidden action the tab the user was on goes back in front
+   * (DEF-PANE-339). */
+  private _showCurrentTab(): void {
+    const shell = this._app.shell as ILabShell;
+    const current = shell.currentWidget;
+    const bar = current && shell.getMainAreaTabBar(current);
+    if (bar) {
+      bar.currentTitle = current.title;
+    }
+  }
+
   /**
    * 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
@@ -369,13 +425,30 @@ export class TerminalManager {
    * 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.
+   *
+   * `spinner` is the token of the action that asked. When the user hid that
+   * action's dialog the terminal is left where it is, and so is a terminal
+   * waiting for the dialog the user then hides (DEF-PANE-339).
    */
-  focus(widget: any): void {
+  focus(widget: any, spinner?: number): void {
     if (!widget || widget.isDisposed) {
       return;
     }
+    if (spinner !== undefined && spinnerHidden(spinner)) {
+      return;
+    }
     if (spinnerDialog && !spinnerDialog.isDisposed) {
-      spinnerDialog.disposed.connect(() => this.focus(widget));
+      spinnerDialog.disposed.connect(() => {
+        // The dialog closes on its own only with its last action. Closed with
+        // an action still running, the user hid it: the terminal is not
+        // activated, and its tab, shown behind the dialog, goes back behind
+        // the user's tab.
+        if (spinnerTitles.size > 0) {
+          this._showCurrentTab();
+        } else {
+          this.focus(widget);
+        }
+      });
       return;
     }
     this._app.shell.activateById(widget.id);

package/style/base.css

@@ -616,17 +616,23 @@ body[data-jp-theme-light='true'] .jp-AiAssistantsPanel-dotHalo {
   border-width: 3px;
 }
 
-/* No focus rim on any button of this extension's dialogs: the primary action
-   is marked by its fill (jp-mod-accept). JupyterLab draws the rim from
+/* A focus rim on a button of this extension's dialogs only when the focus
+   came from the keyboard; the primary action is marked by its fill
+   (jp-mod-accept). JupyterLab draws the rim from
    `button.jp-Dialog-button.jp-mod-styled.jp-mod-accept:focus` and its warn and
    reject siblings in apputils' dialog.css - on :focus, not :focus-visible -
    and a Dialog focuses its default button when it attaches, so the rim showed
-   on a dialog opened with the mouse too. Scoped through the footer mark of
-   the extension's dialog renderer (src/core/dialogs.ts); the second selector
-   outranks those four-class rules. */
-.jp-Dialog:has(.jp-AiAssistantsPanel-dialogFooter) button:focus,
+   on a dialog opened with the mouse too (DEF-PANE-328-FOCUS-RIM). The rule
+   removes it where the browser does not mark the focus :focus-visible: after
+   a mouse click, and on the default button of a dialog opened with the
+   mouse. Keyboard focus keeps JupyterLab's rim (ACC-PANE-217-FOCUS-OUTLINE).
+   Scoped through the footer mark of the extension's dialog renderer
+   (src/core/dialogs.ts); the second selector outranks those four-class
+   rules. */
 .jp-Dialog:has(.jp-AiAssistantsPanel-dialogFooter)
-  button.jp-Dialog-button.jp-mod-styled:focus {
+  button:focus:not(:focus-visible),
+.jp-Dialog:has(.jp-AiAssistantsPanel-dialogFooter)
+  button.jp-Dialog-button.jp-mod-styled:focus:not(:focus-visible) {
   outline: none;
 }
 
@@ -1126,3 +1132,10 @@ body[data-jp-theme-light='true'] .jp-AiAssistantsPanel-dotHalo {
 .jp-AiAssistantsCallback-status[data-level='error'] {
   color: var(--jp-error-color1);
 }
+
+/* Launcher tile glyph at 75% of JupyterLab's own tile glyph (ACC-LNCH-215).
+   A transform, so the 52px icon box and the card layout stay as they are and
+   the svg shrinks about its own centre. */
+.jp-LauncherCard-icon .jp-AiAssistantsLauncher-tileGlyph > svg {
+  transform: scale(0.75);
+}