jupyterlab_ai_code_assistants_extension 1.2.163 → 1.2.236

package/README.md

@@ -32,7 +32,7 @@ Chat-panel extensions re-implement the agent loop and trail the real tool. This
 - **One-click resume** - click a row to jump back into that session in a terminal; an open terminal for the project is reused instead of duplicated. Exception: a Kimi or DeepSeek conversation started with `+` runs under an id that never reaches its process command line, so a click on that row while its terminal stays open opens a second terminal. Codex mints the id for a conversation started with `+` and for a fork through its own app-server before the terminal opens, so a click on a Codex row reuses the open terminal instead of opening a second one
 - **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
+- **Your terminal's `claude -c` follows the panel** (Claude) - clicking a conversation row, or opening it with Enter or Space, makes plain `claude -c` in that project resume that same conversation, including one that has been compacted, which Claude Code otherwise refuses to continue; a click that reuses a running terminal counts too. A launch from the context menu repairs a compacted conversation the same way but only opens it, so it does not move 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, 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

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.d.ts

@@ -45,6 +45,9 @@ export declare class AssistantSessionsPanel extends Widget {
     protected onBeforeHide(_msg: Message): void;
     protected onCloseRequest(msg: Message): void;
     private _buildShell;
+    /** The press in the list has ended. The click it sends is dispatched in the
+     * same task as this release, so the waiting redraw runs in the next one. */
+    private _onRelease;
     /** 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;
@@ -134,13 +137,19 @@ export declare class AssistantSessionsPanel extends Widget {
      * The tile's whole click path lives here rather than in `src/index.ts`
      * because every input it needs is already the panel's: the root join, the
      * listing fetch, the terminal reuse ladder and the settings-resolved launch
-     * mode. Nothing here retries and nothing is scheduled: a guard that refuses
-     * shows one notification and launches nothing, and a request that fails
-     * writes nothing.
+     * mode. Nothing here retries: a guard that refuses shows one notification
+     * and launches nothing, and a request that fails writes nothing. Past the
+     * guards the path waits for the tile launches of every assistant and the
+     * launches of this panel clicked before it, and every launch of any panel
+     * clicked after it waits for it (DEF-PANE-345).
      *
      * `cwd` is a Contents-API path, `''` for the root.
      */
     launchHere(cwd?: string): Promise<any>;
+    /** The tile's click path past its guards, run after the tile launches of
+     * every assistant and the launches of this panel clicked before it, and
+     * before every launch clicked after it (DEF-PANE-345). */
+    private _launchIn;
     /** Start a brand-new conversation in the file browser's current folder. */
     private _newSession;
     /** Branch the active row's current conversation. Every `forkStrategy` has
@@ -180,8 +189,28 @@ export declare class AssistantSessionsPanel extends Widget {
      * per conversation may have none to rewrite yet - so it gets words rather
      * than the raw code. */
     private _renameError;
-    /** Make another conversation the row's current one. */
+    /** Make another conversation the row's current one. `click` is the number
+     * of the action that asked: a row click carries the number it took when it
+     * was pressed, so when its open resolves after a newer row click, an
+     * explicit switch or a fork, it leaves that newer decision in place and
+     * posts nothing (DEF-PANE-349). The decision is posted through the project's
+     * chain, so its write lands after every switch enqueued before it. */
     private _switchBranch;
+    /** Queue a switch post for `session`'s project behind every post already
+     * queued for it, so the server receives the writes in the order the user
+     * acted and the last one to land is the newest decision (DEF-PANE-349).
+     *
+     * A task reads the newest recorded decision when it runs: a row click's
+     * task posts it only if no task has posted that click yet, so clicks that
+     * queue behind one another collapse to the newest. A fork correction is
+     * forced - the fork's own pin write landed after the last post, so the
+     * newest decision has to be written again even when it is already marked
+     * posted. A chain entry is removed when its last task settles. */
+    private _enqueueSwitch;
+    /** Post `sessionId` as the project's current conversation and report the
+     * outcome. Neither reads nor writes the project's token: the project's
+     * chain chooses the id from the recorded decision - see `_enqueueSwitch`. */
+    private _postSwitch;
     /** Delete conversations of the active row's project. Resolves with the
      * removed count, or null on a failure already reported to the user. */
     private _deleteBranches;
@@ -332,12 +361,31 @@ export declare class AssistantSessionsPanel extends Widget {
     /** The last branch listing fetched, and the project it belongs to. Read only
      * when this open's own fetch did not arrive in time. */
     private _branchCache;
+    /** The number and session id of the newest action that decided each
+     * project's current conversation, by encoded path - see `_switchBranch`
+     * (DEF-PANE-349). The id is kept so a fork's late server writes can be
+     * corrected by re-posting the newer decision. */
+    private _currentTokens;
+    /** The switch posts queued per project, by encoded path, and the click
+     * number each project's chain posted last - see `_enqueueSwitch`. A chain
+     * entry is removed when its last task settles; the posted number stays, so a
+     * later task can tell an already-posted decision from a new one. */
+    private _switchChains;
+    private _postedClicks;
     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. */
     private _polling;
+    /** Listing requests sent, and the number of the newest one drawn - see
+     * `_fetch`. */
+    private _fetchSent;
+    private _fetchDrawn;
+    /** A button is pressed in the list, and a redraw waits for its release -
+     * see `_onRelease`. */
+    private _pressed;
+    private _redrawWaits;
     private _presentationMode;
     private _recentLimit;
     private _modes;

package/lib/core/panel.js

@@ -71,6 +71,15 @@ export const MOVE_PANELS_COMMAND = 'ai-code-assistants:move-panels';
  * order the answers arrived, and the file browser could end on the session
  * opened first. */
 let fileBrowserMoves = Promise.resolve();
+/** The session opens of every panel, numbered in click order, and the number
+ * of the newest one whose move ran. An open that finishes after the open of a
+ * later click does not move the file browser, so it ends on the folder of the
+ * newest click that opened (DEF-PANE-343). The same counter orders the writes
+ * that decide a project's current conversation: a row click, an explicit
+ * switch and a fork each take a number, and a row click posts its deferred
+ * switch only while it is the newest (DEF-PANE-349). */
+let openClicks = 0;
+let movedClick = 0;
 function loadExpanded(storageKey) {
     try {
         const raw = window.localStorage.getItem(storageKey);
@@ -109,6 +118,19 @@ export class AssistantSessionsPanel extends Widget {
     constructor(options) {
         var _a, _b, _c, _d, _e;
         super();
+        /** The press in the list has ended. The click it sends is dispatched in the
+         * same task as this release, so the waiting redraw runs in the next one. */
+        this._onRelease = () => {
+            if (!this._pressed) {
+                return;
+            }
+            this._pressed = false;
+            window.setTimeout(() => {
+                if (this._redrawWaits && !this.isDisposed) {
+                    this._render();
+                }
+            }, 0);
+        };
         this._rootDir = '';
         this._deleteToTrash = true;
         this._removingPaths = new Set();
@@ -136,12 +158,31 @@ export class AssistantSessionsPanel extends Widget {
         /** The last branch listing fetched, and the project it belongs to. Read only
          * when this open's own fetch did not arrive in time. */
         this._branchCache = null;
+        /** The number and session id of the newest action that decided each
+         * project's current conversation, by encoded path - see `_switchBranch`
+         * (DEF-PANE-349). The id is kept so a fork's late server writes can be
+         * corrected by re-posting the newer decision. */
+        this._currentTokens = new Map();
+        /** The switch posts queued per project, by encoded path, and the click
+         * number each project's chain posted last - see `_enqueueSwitch`. A chain
+         * entry is removed when its last task settles; the posted number stays, so a
+         * later task can tell an already-posted decision from a new one. */
+        this._switchChains = new Map();
+        this._postedClicks = new Map();
         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. */
         this._polling = null;
+        /** Listing requests sent, and the number of the newest one drawn - see
+         * `_fetch`. */
+        this._fetchSent = 0;
+        this._fetchDrawn = 0;
+        /** A button is pressed in the list, and a redraw waits for its release -
+         * see `_onRelease`. */
+        this._pressed = false;
+        this._redrawWaits = false;
         this._presentationMode = DEFAULT_PRESENTATION_MODE;
         this._recentLimit = DEFAULT_RECENT_LIMIT;
         this._modes = {};
@@ -184,6 +225,8 @@ export class AssistantSessionsPanel extends Widget {
         return this._descriptor;
     }
     dispose() {
+        document.removeEventListener('pointerup', this._onRelease, true);
+        document.removeEventListener('pointercancel', this._onRelease, true);
         this._stopPolling();
         // Disabling a provider must leave its running terminals alive and only
         // drop the tint this panel applied.
@@ -407,6 +450,15 @@ export class AssistantSessionsPanel extends Widget {
         this._bodyEl = body;
         this._loadingEl = loading;
         this._errorEl = error;
+        // A row drawn again between the press and the release of a click loses
+        // the click: the browser sends it to the list the two rows share, not to
+        // the row (DEF-PANE-346). A redraw asked for while a button is pressed in
+        // the list waits until that click has been sent.
+        body.addEventListener('pointerdown', () => {
+            this._pressed = true;
+        });
+        document.addEventListener('pointerup', this._onRelease, true);
+        document.addEventListener('pointercancel', this._onRelease, true);
     }
     /** Show / hide the filter input. Hiding also clears the active filter, so
      * the user never returns to an "invisible" filter narrowing the rows. */
@@ -578,9 +630,16 @@ export class AssistantSessionsPanel extends Widget {
     // ------------------------------------------------------------------- data
     async _fetch() {
         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).
+        const request = ++this._fetchSent;
         // `cache: 'no-store'` so a manual refresh always re-reads the server's
         // view rather than a possibly stale browser-cached response.
         const data = await requestProvider(this._descriptor.id, 'sessions', this._serverSettings, { cache: 'no-store' });
+        if (request < this._fetchDrawn) {
+            return;
+        }
+        this._fetchDrawn = request;
         this._sessions = (_a = data.sessions) !== null && _a !== void 0 ? _a : [];
         this._setInlineError(null);
         this._terminals.setSessions(this._sessions);
@@ -753,15 +812,32 @@ export class AssistantSessionsPanel extends Widget {
     _launchMode(force) {
         return resolveLaunchMode(this._descriptor.launchModes, this._modes, force);
     }
-    async _openSession(session, force, sessionId) {
+    async _openSession(session, force, sessionId, makeCurrent = false) {
         // The click's own feedback, raised before the terminal walk and the
         // 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);
+        const click = ++openClicks;
+        const mode = this._launchMode(force);
         try {
-            await this._terminals.openSession(session, this._launchMode(force), sessionId, busy);
+            await this._terminals.inClickOrder(() => this._terminals.openSession(session, mode, sessionId, busy));
+            if (makeCurrent) {
+                // The row's own controls make that conversation the project's current
+                // one - the pin and the `claude -c` mtime lead (DEF-PANE-349). Not
+                // awaited: the open has succeeded, and the switch is not part of it.
+                // It carries this click's number, so a switch or fork made after this
+                // click wins even when this open finishes last. Other launches leave
+                // `claude -c` alone.
+                void this._switchBranch(session, session.session_id, click);
+            }
             // Not awaited: the open has succeeded, and the sync is not part of it.
-            fileBrowserMoves = fileBrowserMoves.then(() => this._moveFileBrowserTo(session));
+            fileBrowserMoves = fileBrowserMoves.then(() => {
+                if (click < movedClick) {
+                    return;
+                }
+                movedClick = click;
+                return this._moveFileBrowserTo(session);
+            });
         }
         catch (err) {
             if (isResponseStatus(err, 404)) {
@@ -861,14 +937,15 @@ export class AssistantSessionsPanel extends Widget {
      * The tile's whole click path lives here rather than in `src/index.ts`
      * because every input it needs is already the panel's: the root join, the
      * listing fetch, the terminal reuse ladder and the settings-resolved launch
-     * mode. Nothing here retries and nothing is scheduled: a guard that refuses
-     * shows one notification and launches nothing, and a request that fails
-     * writes nothing.
+     * mode. Nothing here retries: a guard that refuses shows one notification
+     * and launches nothing, and a request that fails writes nothing. Past the
+     * guards the path waits for the tile launches of every assistant and the
+     * launches of this panel clicked before it, and every launch of any panel
+     * clicked after it waits for it (DEF-PANE-345).
      *
      * `cwd` is a Contents-API path, `''` for the root.
      */
     async launchHere(cwd) {
-        var _a, _b;
         // No roster yet, so the root is unknown. Joining onto an empty one names a
         // folder at the filesystem root, which the server accepts whenever it
         // happens to exist (ACC-LNCH-148, DEF-132).
@@ -891,7 +968,16 @@ export class AssistantSessionsPanel extends Widget {
             return undefined;
         }
         const folder = this._currentFolder(cwd);
+        return this._terminals.tileInClickOrder(() => this._launchIn(folder));
+    }
+    /** The tile's click path past its guards, run after the tile launches of
+     * every assistant and the launches of this panel clicked before it, and
+     * before every launch clicked after it (DEF-PANE-345). */
+    async _launchIn(folder) {
+        var _a, _b, _c, _d, _e;
         let argv;
+        // The conversation the new terminal runs, when its id is known here.
+        let conversation;
         try {
             // Every click asks the server for the listing (ACC-LNCH-151). `_sessions`
             // is written by `_fetch` and by the optimistic remove in
@@ -910,10 +996,13 @@ export class AssistantSessionsPanel extends Widget {
                 // The folder is required as well: a transcript re-homed into another
                 // project keeps its id, and that terminal is not this folder's
                 // (DEF-PANE-319).
-                const found = await this._terminals.findForSession(row.session_id, folder);
+                // The terminal a launch before this click opened for it counts too,
+                // before the server can read the conversation off its process
+                // (DEF-PANE-345).
+                const found = (_c = this._terminals.cached(folder, row.session_id)) !== null && _c !== void 0 ? _c : (_d = (await this._terminals.findForSession(row.session_id, folder))) === null || _d === void 0 ? void 0 : _d.widget;
                 if (found) {
-                    this._terminals.focus(found.widget);
-                    return found.widget;
+                    this._terminals.focus(found);
+                    return found;
                 }
             }
             const request = {
@@ -929,6 +1018,7 @@ export class AssistantSessionsPanel extends Widget {
             };
             const answer = await requestProvider(this._descriptor.id, 'launch-argv', this._serverSettings, { method: 'POST', body: JSON.stringify(request) });
             argv = answer.argv;
+            conversation = (_e = request.session_id) !== null && _e !== void 0 ? _e : request.new_session_id;
         }
         catch (err) {
             const message = err instanceof Error ? err.message : String(err);
@@ -952,10 +1042,14 @@ export class AssistantSessionsPanel extends Widget {
         // and the Launcher keeps its tab (ACC-LNCH-157 covers the success path
         // only).
         try {
-            return await this._app.commands.execute(BASIC_TERMINAL_LAUNCH, {
+            const widget = await this._app.commands.execute(BASIC_TERMINAL_LAUNCH, {
                 argv,
                 cwd: folder
             });
+            if (widget === null || widget === void 0 ? void 0 : widget.id) {
+                this._terminals.remember(folder, widget, conversation);
+            }
+            return widget;
         }
         catch (err) {
             this._notifyLaunchError('Could not open a terminal for this folder', err);
@@ -977,13 +1071,17 @@ export class AssistantSessionsPanel extends Widget {
         // store key lets the server clear that pin so the new conversation is not
         // shadowed by a stale one (DEF-9).
         const existing = ((_a = this._sessions) !== null && _a !== void 0 ? _a : []).find(s => s.project_path === projectPath);
+        // Raised on the click, not by the launch: the launch waits for a tile
+        // launch clicked before it (DEF-PANE-345).
+        const busy = beginSpinner(this._trans.__('Opening %1', this._descriptor.label), this._trans);
+        const request = {
+            project_path: projectPath,
+            encoded_path: existing === null || existing === void 0 ? void 0 : existing.encoded_path,
+            new_session_id: newId,
+            mode: this._launchMode(force)
+        };
         try {
-            await this._terminals.launch({
-                project_path: projectPath,
-                encoded_path: existing === null || existing === void 0 ? void 0 : existing.encoded_path,
-                new_session_id: newId,
-                mode: this._launchMode(force)
-            }, newId);
+            await this._terminals.inClickOrder(() => this._terminals.launch(request, newId, busy));
         }
         catch (err) {
             // Same shape as `_openSession` above - the `finally` refetches, so an
@@ -991,6 +1089,7 @@ export class AssistantSessionsPanel extends Widget {
             this._notifyLaunchError('Could not start a new session', err);
         }
         finally {
+            endSpinner(busy);
             void this._fetch().catch(() => undefined);
         }
     }
@@ -1006,8 +1105,9 @@ export class AssistantSessionsPanel extends Widget {
         // (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);
+        const click = ++openClicks;
         try {
-            await this._branchByServerCopy(session, undefined, force, busy);
+            await this._terminals.inClickOrder(() => this._branchByServerCopy(session, undefined, force, busy, click));
         }
         finally {
             endSpinner(busy);
@@ -1017,7 +1117,8 @@ export class AssistantSessionsPanel extends Widget {
      * opens - `server-copy` copies the store entry, `server-native` drives the
      * assistant's own non-interactive fork path - so one refresh surfaces the
      * branch. `spinner` is the click's token, which the launch joins. */
-    async _branchByServerCopy(session, name, force, spinner) {
+    async _branchByServerCopy(session, name, force, spinner, click = ++openClicks) {
+        var _a;
         // 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
@@ -1045,6 +1146,32 @@ export class AssistantSessionsPanel extends Widget {
                 })
             });
             minted = true;
+            // The fork route has already written the child's pin, so a row click
+            // still opening from before the Branch must not put the parent back
+            // (DEF-PANE-349). The number is the Branch click's: a row clicked after
+            // it outranks it and a row clicked before it stays suppressed. A newer
+            // click has already switched the project, and the fork's own writes
+            // landed after the user chose that conversation, so the correction is
+            // queued on the project's chain - forced, because that decision may
+            // already be marked posted - and it re-posts the newest decision after
+            // the fork's writes. Otherwise the guard stops a fork that answers
+            // after that later row's switch from lowering the recorded number.
+            const recorded = this._currentTokens.get(session.encoded_path);
+            if (recorded && recorded.click > click) {
+                void this._enqueueSwitch(session, true);
+            }
+            else if (click > ((_a = recorded === null || recorded === void 0 ? void 0 : recorded.click) !== null && _a !== void 0 ? _a : 0)) {
+                this._currentTokens.set(session.encoded_path, {
+                    click,
+                    sessionId: fork.session_id
+                });
+                // A switch post dispatched before this fork can still land after the
+                // fork route's pin write, so the fork is queued on the project's chain
+                // behind it and written again once that post settles. The chain reads
+                // the newest recorded decision when it runs, so a row clicked later
+                // still wins.
+                void this._enqueueSwitch(session, true);
+            }
             // No colour write here. `BranchHandler` already inherited it while
             // minting this fork, from a read taken server-side at request time -
             // strictly fresher than the click-time read this would repeat, and the
@@ -1057,10 +1184,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 +1197,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);
             }
@@ -1172,8 +1299,56 @@ export class AssistantSessionsPanel extends Widget {
         }
         return `Rename failed: ${err}`;
     }
-    /** Make another conversation the row's current one. */
-    async _switchBranch(session, sessionId) {
+    /** Make another conversation the row's current one. `click` is the number
+     * of the action that asked: a row click carries the number it took when it
+     * was pressed, so when its open resolves after a newer row click, an
+     * explicit switch or a fork, it leaves that newer decision in place and
+     * posts nothing (DEF-PANE-349). The decision is posted through the project's
+     * chain, so its write lands after every switch enqueued before it. */
+    async _switchBranch(session, sessionId, click = ++openClicks) {
+        var _a, _b;
+        if (click <= ((_b = (_a = this._currentTokens.get(session.encoded_path)) === null || _a === void 0 ? void 0 : _a.click) !== null && _b !== void 0 ? _b : 0)) {
+            return;
+        }
+        this._currentTokens.set(session.encoded_path, { click, sessionId });
+        await this._enqueueSwitch(session);
+    }
+    /** Queue a switch post for `session`'s project behind every post already
+     * queued for it, so the server receives the writes in the order the user
+     * acted and the last one to land is the newest decision (DEF-PANE-349).
+     *
+     * A task reads the newest recorded decision when it runs: a row click's
+     * task posts it only if no task has posted that click yet, so clicks that
+     * queue behind one another collapse to the newest. A fork correction is
+     * forced - the fork's own pin write landed after the last post, so the
+     * newest decision has to be written again even when it is already marked
+     * posted. A chain entry is removed when its last task settles. */
+    _enqueueSwitch(session, force = false) {
+        var _a;
+        const key = session.encoded_path;
+        const run = ((_a = this._switchChains.get(key)) !== null && _a !== void 0 ? _a : Promise.resolve()).then(async () => {
+            const newest = this._currentTokens.get(key);
+            if (!newest) {
+                return;
+            }
+            if (!force && this._postedClicks.get(key) === newest.click) {
+                return;
+            }
+            this._postedClicks.set(key, newest.click);
+            await this._postSwitch(session, newest.sessionId);
+        });
+        this._switchChains.set(key, run);
+        void run.then(() => {
+            if (this._switchChains.get(key) === run) {
+                this._switchChains.delete(key);
+            }
+        });
+        return run;
+    }
+    /** Post `sessionId` as the project's current conversation and report the
+     * outcome. Neither reads nor writes the project's token: the project's
+     * chain chooses the id from the recorded decision - see `_enqueueSwitch`. */
+    async _postSwitch(session, sessionId) {
         try {
             const result = await requestProvider(this._descriptor.id, 'switch', this._serverSettings, {
                 method: 'POST',
@@ -1192,8 +1367,8 @@ export class AssistantSessionsPanel extends Widget {
                 : `Switch failed: ${err}`, { autoClose: 4000 });
         }
         finally {
-            // Best-effort refresh - never let a transient failure reject this
-            // fire-and-forget switch (callers do not await it).
+            // Best-effort refresh - never let a transient failure reject the switch:
+            // the user action that asked for it is fire-and-forget.
             await this._fetch().catch(() => undefined);
         }
     }
@@ -1299,6 +1474,11 @@ export class AssistantSessionsPanel extends Widget {
     }
     _render() {
         var _a, _b, _c, _d, _e;
+        if (this._pressed) {
+            this._redrawWaits = true;
+            return;
+        }
+        this._redrawWaits = false;
         const sessions = (_a = this._sessions) !== null && _a !== void 0 ? _a : [];
         // Capture scrollTop per section so a polling refresh does not reset the
         // user's place. The body scrolls too in short windows - clearing innerHTML
@@ -1542,7 +1722,9 @@ export class AssistantSessionsPanel extends Widget {
             if (removing) {
                 return;
             }
-            void this._openSession(session);
+            // The row's own controls also make the conversation current, rather
+            // than only opening it (DEF-PANE-349).
+            void this._openSession(session, undefined, undefined, true);
         });
         row.addEventListener('contextmenu', e => {
             e.preventDefault();
@@ -1591,7 +1773,9 @@ export class AssistantSessionsPanel extends Widget {
             if (e.key === 'Enter' || e.key === ' ') {
                 // Space would scroll the list otherwise.
                 e.preventDefault();
-                void this._openSession(session);
+                // The keyboard's row click, so it makes the conversation current
+                // exactly as the pointer's does (DEF-PANE-349).
+                void this._openSession(session, undefined, undefined, true);
                 return;
             }
             // The two keyboard routes to a context menu. Anchored on the row's own

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();