jupyterlab_ai_code_assistants_extension 1.2.199 → 1.2.271

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/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,35 @@ 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;
+    /** The `_fetchSent` number at each removal's DELETE, by encoded path. A
+     * listing sent before that number may still carry the removed project, so
+     * `_fetch` drops it (DEF-PANE-351-WRITE-ORDER). */
+    private readonly _removedAt;
+    /** 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

@@ -1,5 +1,5 @@
 import { Clipboard, Dialog, InputDialog, Notification, showDialog } from '@jupyterlab/apputils';
-import { MenuSvg, closeIcon, editIcon, folderIcon, terminalIcon } from '@jupyterlab/ui-components';
+import { MenuSvg, closeIcon, copyIcon, editIcon, folderIcon, terminalIcon } from '@jupyterlab/ui-components';
 import { nullTranslator } from '@jupyterlab/translation';
 import { CommandRegistry } from '@lumino/commands';
 import { UUID } from '@lumino/coreutils';
@@ -71,6 +71,16 @@ 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, a fork and a New Session (+) each take a number, and a row click
+ * posts its deferred switch only while it is the newest (DEF-PANE-349,
+ * DEF-PANE-355). */
+let openClicks = 0;
+let movedClick = 0;
 function loadExpanded(storageKey) {
     try {
         const raw = window.localStorage.getItem(storageKey);
@@ -109,6 +119,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 +159,35 @@ 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;
+        /** The `_fetchSent` number at each removal's DELETE, by encoded path. A
+         * listing sent before that number may still carry the removed project, so
+         * `_fetch` drops it (DEF-PANE-351-WRITE-ORDER). */
+        this._removedAt = new Map();
+        /** 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 +230,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 +455,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,10 +635,19 @@ 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' });
-        this._sessions = (_a = data.sessions) !== null && _a !== void 0 ? _a : [];
+        if (request < this._fetchDrawn) {
+            return;
+        }
+        this._fetchDrawn = request;
+        // A project removed at or after this listing was sent must not be drawn
+        // back from the answer (DEF-PANE-351-WRITE-ORDER).
+        this._sessions = ((_a = data.sessions) !== null && _a !== void 0 ? _a : []).filter(s => { var _a; return ((_a = this._removedAt.get(s.encoded_path)) !== null && _a !== void 0 ? _a : 0) < request; });
         this._setInlineError(null);
         this._terminals.setSessions(this._sessions);
         this._render();
@@ -600,6 +666,10 @@ export class AssistantSessionsPanel extends Widget {
                     favourite: next
                 })
             });
+            // A listing sent before the write may still be drawn, and a poll may
+            // have replaced the row this wrote; this one is answered after the write
+            // (DEF-PANE-351).
+            void this._fetch().catch(() => undefined);
         }
         catch (err) {
             session.favourite = !next; // roll back
@@ -652,6 +722,11 @@ export class AssistantSessionsPanel extends Widget {
             });
             // Drop locally; the next poll reconciles against disk.
             this._sessions = ((_a = this._sessions) !== null && _a !== void 0 ? _a : []).filter(s => s.encoded_path !== session.encoded_path);
+            // A listing sent before the delete may still be drawn (DEF-PANE-351),
+            // and it carries the removed project: the number taken here marks the
+            // answer for `_fetch` to drop (DEF-PANE-351-WRITE-ORDER).
+            this._removedAt.set(session.encoded_path, this._fetchSent);
+            void this._fetch().catch(() => undefined);
         }
         catch (err) {
             this._showActionError(`Could not remove "${name}" - try again.`, err);
@@ -753,15 +828,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 +953,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 +984,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 +1012,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 = (await 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 +1034,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 +1058,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 +1087,26 @@ 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);
+        if (existing) {
+            // The + click is the project's newest decision: a row open still
+            // finishing posts no switch over it (DEF-PANE-355). It has no id to post;
+            // the launch route clears the pin.
+            this._currentTokens.set(existing.encoded_path, {
+                click: ++openClicks,
+                sessionId: ''
+            });
+        }
+        // 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 +1114,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 +1130,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 +1142,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 +1171,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
@@ -1172,8 +1324,57 @@ 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);
+            // An empty id is a New Session (+) decision, which posts nothing.
+            if (!(newest === null || newest === void 0 ? void 0 : newest.sessionId)) {
+                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 +1393,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 +1500,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 +1748,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 +1799,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
@@ -1913,6 +2123,7 @@ export class AssistantSessionsPanel extends Widget {
         });
         this._commands.addCommand(this._cmd('copy-path'), {
             label: this._trans.__('Copy Path'),
+            icon: copyIcon,
             execute: () => {
                 const s = active();
                 if (s) {
@@ -1922,6 +2133,7 @@ export class AssistantSessionsPanel extends Widget {
         });
         this._commands.addCommand(this._cmd('copy-session-id'), {
             label: this._trans.__('Copy Session ID'),
+            icon: copyIcon,
             execute: () => {
                 var _a;
                 const id = (_a = active()) === null || _a === void 0 ? void 0 : _a.session_id;
@@ -1961,6 +2173,9 @@ export class AssistantSessionsPanel extends Widget {
             // item beside an ordinary one (DEF-45). The sweep variant of the trash
             // glyph, because this one deletes several at once.
             icon: cleanupIcon,
+            // Both history-deleting entries draw their icon in the error colour
+            // (base.css).
+            className: 'jp-AiAssistantsContextMenu-danger',
             isVisible: () => { var _a, _b; return ((_b = (_a = active()) === null || _a === void 0 ? void 0 : _a.extra_sessions) !== null && _b !== void 0 ? _b : 0) > 0; },
             execute: () => {
                 const s = active();
@@ -2057,6 +2272,7 @@ export class AssistantSessionsPanel extends Widget {
         this._commands.addCommand(this._cmd('remove'), {
             label: `Remove from ${this._descriptor.label}`,
             icon: removeIcon,
+            className: 'jp-AiAssistantsContextMenu-danger',
             execute: () => {
                 const s = active();
                 if (s) {