jupyterlab_ai_code_assistants_extension 1.2.236 → 1.2.282

package/README.md

@@ -25,30 +25,30 @@ Chat-panel extensions re-implement the agent loop and trail the real tool. This
 
 ## Features
 
-- **One install, every assistant** - Claude Code, Codex, Kimi, Gemini and DeepSeek from a single package, each with its own right-side panel wearing its official mark
-- **Provider registry** - assistant-specific behaviour lives in one module per assistant behind capability flags; no core file names an assistant, and adding one touches no core file
-- **Joint settings page** - one settings section covering all assistants, with a per-assistant toggle (all on by default); toggling takes effect live, no JupyterLab reload, and a change reaches the other JupyterLab windows of the same browser
-- **Three-section side panel** - Favorites, Recent, and All projects, each scrolling independently
-- **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) - 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
-- **Launch modes under each assistant's own name** - Claude's skip-permissions, Codex's approval bypass, Kimi's `--yolo`, Gemini's YOLO; unsafe variants carry a shield glyph in the launch menus
-- **Coloured terminal tabs** - each session's colour tints its terminal tab via the companion `jupyterlab_colourful_tab_extension` (installed automatically). Claude's own `/color` supplies its default, Kimi derives a stable colour from the conversation id; Codex, Gemini and DeepSeek have no colour of their own until you set one, and a branched session inherits its parent's colour, which it keeps even if the parent's colour later changes or is reset. A conversation cleared with `/clear` keeps its colour too: the replacement inherits it, and a colour the replacement already has is kept. Tinting needs the companion release that reports the colours you pick and lets another extension own a tab - against an older one this extension tints no tabs at all and says so once, and the companion's own right-click colours keep working as they always did
-- **Your newest colour choice wins** - set a colour on a terminal tab and the extension remembers it for that conversation, so the tab shows it again when you reopen the conversation. In Claude Code, `/color` is the second way to choose, and whichever you used last wins: a colour picked on the tab after `/color` stays, and running `/color` after a pick takes over again, including `/color` with the same colour or a `/color` reset. `Reset Tab Colour (n)` in the session's right-click menu hands back every colour you set by hand on that project's conversations, and appears once there is one to hand back. Clearing the colour on the tab itself releases it too, for the conversation that terminal is running; `Reset Tab Colour` is the way back for a conversation with no tab open. A Kimi or DeepSeek conversation that has never been resumed cannot be tracked yet, so a colour set on its tab is not kept
-- **Favorites** - star projects you keep coming back to via the right-click menu; favourites from the standalone extensions are migrated on first run
-- **Remove and clean up** - drop a project's history or a project's extra parallel sessions from the right-click menu, confirmation dialog first; removed files honour JupyterLab's "move files to trash" setting
-- **Activity at a glance** - each row shows its last activity in an aligned column; rows active within the last minute light up, rows idle for over a week dim, and rows with parallel conversations show a branch icon with the count
-- **Remote control indicator and background agents** (Claude) - a green dot marks sessions actively under remote control, and a conversation held by a running background agent shows a `bg` chip; clicking stops the agent and resumes the same conversation in your terminal, so it becomes an ordinary interactive session
-- **Search** - fuzzy filter per panel, toggled by the funnel button
+- **One install, every assistant** - Claude Code, Codex, Kimi, Gemini and DeepSeek in one package, each with its own right-side panel and official mark
+- **Provider registry** - assistant-specific behaviour lives in one module per assistant, so adding one changes no core file
+- **Joint settings page** - one settings section covers all assistants with a per-assistant toggle, all on by default; toggling takes effect without a JupyterLab reload
+- **Three-section side panel** - Favorites, Recent and All projects, each scrolling independently
+- **One-click resume** - click a row to resume its session in a terminal, reusing an open terminal for the project. A Kimi or DeepSeek conversation started with `+` opens a second terminal when its first is still open
+- **File browser follows the opened session** - opening a session moves the file browser to its 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** - each enabled assistant has a tile in the Launcher's AI Assistants section; a click opens the assistant in the file browser's current folder, resuming that folder's conversation when one exists
+- **Your terminal's `claude -c` follows the panel** (Claude) - selecting a conversation row makes plain `claude -c` in that project resume the same conversation, even one that has been compacted
+- **Conversation switcher** - a right-click "Switch and Manage Sessions" submenu lists a project's other conversations by name and short id. "Manage Sessions..." opens a searchable list with multi-select delete and copy-id
+- **Branch session** - fork the current conversation into a new named session from the right-click menu
+- **Rename session** - name a conversation from the right-click menu, and the panel shows the name the assistant itself kept
+- **Launch modes under each assistant's own name** - Claude's skip-permissions, Codex's approval bypass, Kimi's `--yolo` and Gemini's YOLO; unsafe variants carry a shield glyph
+- **Coloured terminal tabs** - each session's colour tints its terminal tab, and a branched session inherits its parent's colour. Claude's `/color` supplies a default and Kimi derives a stable one; Codex, Gemini and DeepSeek have no colour until you set one
+- **Your newest colour choice wins** - a colour set on a terminal tab is remembered for that conversation; a Kimi or DeepSeek conversation that has never been resumed, including one started with `+`, is the exception, because its id cannot be read yet. In Claude Code whichever of the tab colour and `/color` you used last wins, and Reset Tab Colour in the right-click menu hands back the colours you set by hand
+- **Favorites** - star projects from the right-click menu; favourites from the standalone extensions are migrated on first run
+- **Remove and clean up** - remove a project's history or its extra parallel sessions from the right-click menu, with a confirmation. Removed files honour JupyterLab's "move files to trash" setting
+- **Activity at a glance** - each row shows its last activity in an aligned column. Recent rows light up, stale rows dim, and parallel conversations show a branch icon and count
+- **Remote control indicator and background agents** (Claude) - a green dot marks sessions under remote control, and a `bg` chip marks a conversation held by a background agent. Clicking stops the agent and resumes the conversation in your terminal
+- **Search** - a fuzzy filter per panel, toggled by the funnel button
 - **Presentation modes** - label rows by session name or by path relative to the JupyterLab root
-- **Conflict-safe upgrade** - if a retired standalone extension is still installed, its panel wins and this extension stands down for that assistant instead of showing a duplicate
-- **DeepSeek in the terminal** - the DeepSeek Harness ships no terminal chat of its own, so its panel runs the community TUI bundle (`@deepseek-harness-tui/dsh-tui`, mounted as the `tui` profile with `dsh plugin --profile tui add @deepseek-harness-tui/dsh-tui`). Without that profile, a launch is refused before a terminal opens, naming the bundle and the mount command - `dsh tui` itself would instead die in a stack trace that prints that command with a literal `<package>` where the package name goes, and never the bundle's name. The panel lists the projects under `~/.dsh/sessions` (or `$DSH_HOME`), and a click resumes that row's conversation with `dsh tui --resume <id>` in a terminal; a launch with no conversation named starts a new one, whose id the TUI mints itself. Branching and deleting work from the panel as for every other assistant
-- **Auto-disabled when absent** - an assistant whose CLI is not on `PATH` does not show a panel
-- **Open Callback** - when an assistant's login sends your browser to an `http://127.0.0.1:...` link that fails to load, because the login is waiting on the machine running JupyterLab, run `Open Callback` from the command palette and paste the link; the Jupyter server requests it for you, and the popup says whether the login accepted it, then closes by itself 3 seconds later. Only `http` links to that machine's own loopback are accepted
+- **Conflict-safe upgrade** - if a retired standalone extension is still installed, its panel wins and this extension stands down for that assistant
+- **DeepSeek in the terminal** - the panel runs the community TUI bundle, because the DeepSeek Harness ships no terminal chat. Without the bundle a launch is refused before a terminal opens
+- **Auto-disabled when absent** - an assistant whose CLI is not on `PATH` shows no panel
+- **Open Callback** - when an assistant's login redirects to a loopback address that will not load, run Open Callback from the command palette and paste the link. The server makes the request and says whether the login accepted it
 
 ## Requirements
 

package/lib/core/panel.d.ts

@@ -382,6 +382,10 @@ export declare class AssistantSessionsPanel extends Widget {
      * `_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;

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';
@@ -76,8 +76,9 @@ let fileBrowserMoves = Promise.resolve();
  * 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). */
+ * 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) {
@@ -179,6 +180,10 @@ export class AssistantSessionsPanel extends Widget {
          * `_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;
@@ -640,7 +645,9 @@ export class AssistantSessionsPanel extends Widget {
             return;
         }
         this._fetchDrawn = request;
-        this._sessions = (_a = data.sessions) !== null && _a !== void 0 ? _a : [];
+        // 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();
@@ -659,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
@@ -711,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);
@@ -721,14 +737,44 @@ export class AssistantSessionsPanel extends Widget {
         }
     }
     async _cleanupParallel(session) {
-        var _a;
-        const extra = session.extra_sessions;
+        var _a, _b, _c, _d;
         const name = this._lookupName(session);
-        const confirm = await showDialog({
-            title: this._trans.__('Clean Up Parallel Sessions'),
-            body: `Remove ${extra} parallel session${extra === 1 ? '' : 's'} from ` +
-                `"${name}"? The current conversation is kept; the rest are ` +
-                `${this._disposalVerb}.${this._irreversibleNote}`,
+        const confirmBody = new Widget();
+        confirmBody.node.className = 'jp-AiAssistantsPanel-cleanupConfirm';
+        const question = document.createElement('p');
+        // Announced politely when the fetch restates it; the warning keeps
+        // role=alert for the case that needs attention.
+        question.setAttribute('role', 'status');
+        let extra = session.extra_sessions;
+        const askCount = (count) => {
+            question.textContent =
+                `Remove ${count} parallel session${count === 1 ? '' : 's'} from ` +
+                    `"${name}"?`;
+        };
+        askCount(extra);
+        confirmBody.node.appendChild(question);
+        // One sentence, twelve words or fewer: what happens, not the detail.
+        const hint = document.createElement('p');
+        hint.className = 'jp-AiAssistantsPanel-cleanupHint';
+        hint.textContent = this._deleteToTrash
+            ? 'The current conversation is kept; the rest go to the trash.'
+            : 'The current conversation is kept; the rest are deleted permanently.';
+        confirmBody.node.appendChild(hint);
+        // The irreversible note is a safety statement, not the hint, so it keeps
+        // its own line. With the trash on it names the refusal: a refused move
+        // deletes permanently, while the hint promises the trash
+        // (DEF-PANE-363-CAUTION-REFUSAL).
+        const caution = document.createElement('p');
+        caution.className = 'jp-AiAssistantsPanel-cleanupCaution';
+        caution.textContent = this._deleteToTrash
+            ? 'A refused trash move deletes permanently and cannot be undone.'
+            : this._irreversibleNote.trim();
+        confirmBody.node.appendChild(caution);
+        const title = this._trans.__('Clean Up Parallel Sessions');
+        let warning = null;
+        const confirmDialog = new Dialog({
+            title,
+            body: confirmBody,
             buttons: [
                 Dialog.cancelButton(),
                 Dialog.warnButton({ label: this._trans.__('Remove') })
@@ -737,6 +783,58 @@ export class AssistantSessionsPanel extends Widget {
             defaultButton: 0,
             renderer: dialogRenderer
         });
+        // showDialog names a dialog only when its body is a string, and this body
+        // is a Widget: name it here, and again when the question is restated and
+        // the warning joins it.
+        const nameDialog = () => {
+            var _a, _b, _c, _d;
+            confirmDialog.node.setAttribute('aria-label', [
+                title,
+                (_a = question.textContent) !== null && _a !== void 0 ? _a : '',
+                (_b = hint.textContent) !== null && _b !== void 0 ? _b : '',
+                (_c = caution.textContent) !== null && _c !== void 0 ? _c : '',
+                (_d = warning === null || warning === void 0 ? void 0 : warning.textContent) !== null && _d !== void 0 ? _d : ''
+            ]
+                .filter(part => part)
+                .join(' '));
+        };
+        nameDialog();
+        // Alongside the question, never in front of it: the request layer allows
+        // 60 s, and the confirmation must open at once. When the list lands the
+        // question states its length and a conversation newer than the kept one
+        // adds the warning, drawn last so it reads after the caution. The same
+        // list is what the removal deletes. A failed fetch leaves the question as
+        // the row reported it, with no warning, and the removal fetches again
+        // below.
+        const branchesReady = this._fetchBranches(session).then(fetched => {
+            const list = fetched === null || fetched === void 0 ? void 0 : fetched.branches;
+            if (list && list.length === 0) {
+                // The row is up to one poll old, and a second client may have
+                // cleaned the project since (DEF-GUARD-96): a red Remove with zero
+                // targets is a dead end. End the confirmation through the accept
+                // path, whose zero-id guard states the empty outcome and refreshes
+                // the list (DEF-PANE-365); resolving after the user already
+                // accepted or cancelled is a no-op.
+                confirmDialog.resolve(1);
+            }
+            else if (list) {
+                extra = list.length;
+                askCount(extra);
+                const newer = list.filter(branch => branch.file_mtime > session.file_mtime).length;
+                if (newer > 0) {
+                    warning = document.createElement('div');
+                    warning.className = 'jp-AiAssistantsPanel-cleanupWarning';
+                    warning.setAttribute('role', 'alert');
+                    warning.textContent =
+                        `${newer} parallel session${newer === 1 ? ' was' : 's were'} ` +
+                            'active after the one kept.';
+                    confirmBody.node.appendChild(warning);
+                }
+                nameDialog();
+            }
+            return fetched;
+        }, () => null);
+        const confirm = await confirmDialog.launch();
         if (!confirm.button.accept) {
             return;
         }
@@ -744,6 +842,7 @@ export class AssistantSessionsPanel extends Widget {
         body.node.className = 'jp-AiAssistantsPanel-cleanupBody';
         const message = document.createElement('div');
         message.className = 'jp-AiAssistantsPanel-cleanupMessage';
+        message.setAttribute('role', 'status');
         message.textContent = `Removing ${extra} parallel session${extra === 1 ? '' : 's'}...`;
         body.node.appendChild(message);
         // No `value` attribute -> indeterminate (animated) while the request is in
@@ -758,6 +857,7 @@ export class AssistantSessionsPanel extends Widget {
             buttons: [Dialog.okButton({ label: this._trans.__('Close') })],
             renderer: dialogRenderer
         });
+        dialog.node.setAttribute('aria-label', title);
         // Close stays live while the work runs. Hiding it took away the only exit
         // a keyboard user has: the dialog listens for Escape on its own node, it
         // puts focus on this button and nowhere else, and focusing a hidden button
@@ -768,9 +868,11 @@ export class AssistantSessionsPanel extends Widget {
         void dialog.launch();
         try {
             // The extras ARE the branch list - the current conversation is not in
-            // it - so cleaning up is deleting exactly those ids.
-            const listed = await this._fetchBranches(session);
-            const ids = listed.branches.map(b => b.session_id);
+            // it - so cleaning up is deleting exactly those ids. Reuse the list the
+            // question was built from, waiting for it here where the progress
+            // dialog is already up; only a failed fetch re-reads.
+            const fetched = (_a = (await branchesReady)) !== null && _a !== void 0 ? _a : (await this._fetchBranches(session));
+            const ids = ((_b = fetched === null || fetched === void 0 ? void 0 : fetched.branches) !== null && _b !== void 0 ? _b : []).map(b => b.session_id);
             if (ids.length === 0) {
                 // The menu item is gated on a row up to one poll old, so by the time
                 // the refetch lands another tab may have cleaned the project already.
@@ -779,6 +881,7 @@ export class AssistantSessionsPanel extends Widget {
                 // to remove N.
                 bar.remove();
                 message.textContent = 'Nothing left to clean up.';
+                dialog.node.setAttribute('aria-label', `${title}. ${(_c = message.textContent) !== null && _c !== void 0 ? _c : ''}`);
                 this._branchCache = null;
                 await this._fetch();
                 return;
@@ -792,7 +895,7 @@ export class AssistantSessionsPanel extends Widget {
             });
             // Only the conversations that ACTUALLY went lose their colour - one the
             // server could not delete keeps its tint.
-            await this._colours.forget((_a = data.removed_ids) !== null && _a !== void 0 ? _a : ids);
+            await this._colours.forget((_d = data.removed_ids) !== null && _d !== void 0 ? _d : ids);
             // The kept listing names conversations that may have just gone.
             this._branchCache = null;
             bar.value = 1;
@@ -999,7 +1102,7 @@ export class AssistantSessionsPanel extends Widget {
                 // 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;
+                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);
                     return found;
@@ -1071,6 +1174,15 @@ 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);
@@ -1328,7 +1440,8 @@ export class AssistantSessionsPanel extends Widget {
         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) {
+            // 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) {
@@ -2097,6 +2210,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) {
@@ -2106,6 +2220,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;
@@ -2145,6 +2260,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();
@@ -2241,6 +2359,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) {

package/lib/core/terminals.d.ts

@@ -86,8 +86,10 @@ export declare class TerminalManager {
      */
     launch(request: ILaunchRequest, tagSessionId?: string, spinner?: number): Promise<any>;
     /** The terminal this manager last opened for `projectPath`, when it is
-     * still open and was opened for the conversation `sessionId`; else null. */
-    cached(projectPath: string, sessionId: string): any | null;
+     * still open, was opened for the conversation `sessionId`, and the server
+     * does not read another conversation off its process - which /clear starts
+     * in the same process (DEF-PANE-350); else null. */
+    cached(projectPath: string, sessionId: string): Promise<any | null>;
     /** Remember `widget` as the newest terminal of `projectPath`, opened for
      * the conversation `sessionId`. A launch is remembered before the server
      * can read the conversation off the new process, so the next open of the

package/lib/core/terminals.js

@@ -383,7 +383,7 @@ export class TerminalManager {
         var _a;
         // 1. Microcache - the most recent terminal of this project, reused only
         // when it carries the wanted conversation.
-        const cached = this.cached(session.project_path, wanted);
+        const cached = await this.cached(session.project_path, wanted);
         if (cached) {
             this.focus(cached, spinner);
             return;
@@ -473,12 +473,24 @@ export class TerminalManager {
         }
     }
     /** The terminal this manager last opened for `projectPath`, when it is
-     * still open and was opened for the conversation `sessionId`; else null. */
-    cached(projectPath, sessionId) {
+     * still open, was opened for the conversation `sessionId`, and the server
+     * does not read another conversation off its process - which /clear starts
+     * in the same process (DEF-PANE-350); else null. */
+    async cached(projectPath, sessionId) {
         const cached = this._byProject.get(projectPath);
-        return cached && !cached.widget.isDisposed && cached.sessionId === sessionId
-            ? cached.widget
-            : null;
+        if (!cached || cached.widget.isDisposed || cached.sessionId !== sessionId) {
+            return null;
+        }
+        // No id read is the window before the new process is readable, which is
+        // what this cache covers (DEF-PANE-345).
+        const info = await this.probe(cached.widget);
+        if ((info === null || info === void 0 ? void 0 : info.session_id) && info.session_id !== sessionId) {
+            if (this._byProject.get(projectPath) === cached) {
+                this._byProject.delete(projectPath);
+            }
+            return null;
+        }
+        return cached.widget;
     }
     /** Remember `widget` as the newest terminal of `projectPath`, opened for
      * the conversation `sessionId`. A launch is remembered before the server

package/lib/index.js

@@ -413,6 +413,31 @@ const plugin = {
                 }
             }
         };
+        // A suspended network stack - laptop asleep, tab backgrounded - is exactly
+        // when the probe fails, and the slow cadence below would leave the roster
+        // stale for up to a minute after the machine comes back. A wake fires
+        // both events, so it costs two probes; deliberately, because a guard that
+        // let the second join the first answered the wake with a request issued
+        // before it, and starved the interval below of its own tick (DEF-117).
+        // Heard from here, before the first await: a wake before the listeners are
+        // armed below is only remembered, because a reconcile before the settings
+        // load reads the enabled-by-default fallback and docks assistants the user
+        // disabled; one status check answers it once they are armed (DEF-GUARD-122).
+        let armed = false;
+        let wokeDuringActivation = false;
+        const reprobe = () => {
+            if (!armed) {
+                wokeDuringActivation = true;
+                return;
+            }
+            void probeStatus().then(reconcile);
+        };
+        window.addEventListener('online', reprobe);
+        document.addEventListener('visibilitychange', () => {
+            if (document.visibilityState === 'visible') {
+                reprobe();
+            }
+        });
         await probeStatus();
         if (settingRegistry) {
             try {
@@ -490,21 +515,10 @@ const plugin = {
         window.setInterval(() => {
             void probeStatus().then(reconcile);
         }, STATUS_INTERVAL_MS);
-        // A suspended network stack - laptop asleep, tab backgrounded - is exactly
-        // when the probe fails, and the slow cadence above would leave the roster
-        // stale for up to a minute after the machine comes back. A wake fires
-        // both events, so it costs two probes; deliberately, because a guard that
-        // let the second join the first answered the wake with a request issued
-        // before it, and starved the interval above of its own tick (DEF-117).
-        const reprobe = () => {
-            void probeStatus().then(reconcile);
-        };
-        window.addEventListener('online', reprobe);
-        document.addEventListener('visibilitychange', () => {
-            if (document.visibilityState === 'visible') {
-                reprobe();
-            }
-        });
+        armed = true;
+        if (wokeDuringActivation) {
+            reprobe();
+        }
         // Each JupyterLab window keeps its own copy of the settings and never
         // reads them again, and every save writes that whole copy. So a window
         // loaded before another window changed a setting put the old value back

package/package.json

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

package/src/__tests__/index.spec.ts

@@ -168,6 +168,97 @@ describe('DEF-GUARD-139 - reconcile hands a late roster to a docked panel', () =
   });
 });
 
+describe('DEF-GUARD-122 - a wake during activation', () => {
+  it('is remembered, reconciles nothing before the settings load, and is answered by one status check once the listeners are armed', async () => {
+    // Identity of this activation's probes; earlier activations' listeners
+    // reach the same mock (see the activation-contract harness below).
+    const serverSettings = {};
+    let probes = 0;
+    request.mockImplementation((path: string, settings: unknown) => {
+      if (path !== 'status' || settings !== serverSettings) {
+        return Promise.reject(new Error('not this activation'));
+      }
+      probes += 1;
+      return Promise.resolve({
+        root_dir: '/srv/lab',
+        delete_to_trash: true,
+        providers: PROVIDERS.map(m => ({
+          id: m.descriptor.id,
+          available: true
+        }))
+      });
+    });
+    const docked: AssistantSessionsPanel[] = [];
+    const labShell = {
+      add: (w: AssistantSessionsPanel) => {
+        docked.push(w);
+      }
+    } as any;
+    const app = {
+      serviceManager: { serverSettings },
+      commands: new CommandRegistry(),
+      hasPlugin: () => false
+    } as any;
+    // Every assistant off, so a reconcile on the enabled-by-default fallback
+    // would show as a docked panel.
+    const composite: Record<string, unknown> = Object.fromEntries(
+      PROVIDERS.map(m => [`providers.${m.descriptor.id}.enabled`, false])
+    );
+    const settings = {
+      raw: '{}',
+      composite,
+      get: (key: string) => ({
+        composite: composite[key],
+        user: composite[key]
+      }),
+      set: async () => undefined,
+      changed: new Signal<unknown, void>({})
+    };
+    let finishLoad!: () => void;
+    const loading = new Promise<void>(resolve => {
+      finishLoad = resolve;
+    });
+    const settingRegistry = {
+      connector: { fetch: async () => ({ raw: settings.raw }) },
+      load: async () => {
+        await loading;
+        return settings;
+      }
+    } as any;
+
+    const activation = (plugin.activate as any)(
+      app,
+      labShell,
+      null,
+      settingRegistry,
+      null,
+      null,
+      null
+    );
+    await flush();
+    expect(probes).toBe(1); // the activation probe; the settings still load
+
+    window.dispatchEvent(new Event('online'));
+    Object.defineProperty(document, 'visibilityState', {
+      configurable: true,
+      get: () => 'visible'
+    });
+    document.dispatchEvent(new Event('visibilitychange'));
+    await flush();
+    expect(probes).toBe(1);
+    expect(docked).toHaveLength(0);
+
+    finishLoad();
+    await activation;
+    await flush();
+    // How this fails: without the remembered wake the count stays 1 until the
+    // 60 s tick; a listener that probes before the settings load docks every
+    // assistant above, and one probe per wake makes it 3.
+    expect(probes).toBe(2);
+    expect(docked).toHaveLength(0);
+  });
+});
+
 describe('ACC-LNCH-143..146 - the Launcher tile has the panel lifecycle', () => {
   /** A roster in which every assistant is present, or every one but `absent`. */
   const roster = (absent?: string): unknown => ({