jupyterlab_ai_code_assistants_extension 1.2.271 → 1.2.288

package/README.md

@@ -10,7 +10,7 @@
 
 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. One install replaces the separate `jupyterlab_claude_code_extension`, `jupyterlab_codex_extension` and `jupyterlab_kimi_code_extension` packages and migrates their settings and favourites automatically.
 
-![Claude Code Sessions panel](.resources/screenshot.png)
+![Claude Code panel](.resources/screenshot.png)
 
 ## Why this extension
 
@@ -25,30 +25,31 @@ 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
+- **Command line** - `jupyterlab-ai-code-assistants` lists, renames, moves, deletes, branches and switches the sessions of every assistant and refreshes the panels, from a terminal or an agent; every open panel shows the change at once
+- **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
 
@@ -76,6 +77,27 @@ pip install jupyterlab_ai_code_assistants_extension
 > [!WARNING]
 > `package.json` pins `webpack: 5.106.0` and `chalk: 4.1.2` in both `resolutions` and `overrides`. Do not remove these. webpack `>= 5.106.1` changed its module-federation share identifier format and crashes the unmaintained `license-webpack-plugin` (`split('=')[1].trim()`) that `@jupyterlab/builder` injects into every production build; the duplicate `chalk@2.4.2` pulled by `duplicate-package-checker-webpack-plugin` crashes on Node 24+ in the build-isolation install. Without the pins, `make publish` and CI fail on `python -m build`.
 
+## Command line
+
+The wheel installs `jupyterlab-ai-code-assistants`. It finds the running Jupyter server and its token, and changes sessions only through that server, so every open panel shows the change at once.
+
+```bash
+jupyterlab-ai-code-assistants                                   # the server and every assistant (status)
+jupyterlab-ai-code-assistants sessions list -a claude -p ~/project
+jupyterlab-ai-code-assistants sessions rename <id> "New name" -a kimi
+jupyterlab-ai-code-assistants sessions move <id> --to ~/other-project -a gemini
+jupyterlab-ai-code-assistants sessions delete <id> -a claude
+jupyterlab-ai-code-assistants sessions branch <id> -a claude --name "Experiment"
+jupyterlab-ai-code-assistants sessions switch <id> -a codex
+jupyterlab-ai-code-assistants refresh                           # after installing or removing an assistant CLI
+```
+
+- `--url` and `--json` go before the subcommand; `--url` chooses the server when several run
+- There is no token option: the token comes from `JUPYTERLAB_AI_CODE_ASSISTANTS_TOKEN`, else the server's runtime record, else `JUPYTERHUB_API_TOKEN`, `JPY_API_TOKEN` or `JUPYTER_TOKEN` for a loopback address
+- A session a running terminal holds is never moved or deleted, and a project's current session is never deleted
+- A Codex move forks the session into the target under a new id, which the command prints, and archives the source
+- `jupyterlab-ai-code-assistants --help` lists the exit codes; `--help` after a subcommand lists its options
+
 ## Agent skill
 
 The wheel ships a session-operations skill for coding agents at `share/jupyter/agents/skills/jupyterlab-ai-code-assistants-extension/SKILL.md`. It covers finding, moving, splitting, renaming and promoting sessions, copying a session into another project under a fresh id, the task-list environment variables, and running Claude Code against Kimi K3 or DeepSeek, with two references for the rest - `claude-operations.md` for how `claude -c` and `--resume` choose a session and how to repair, promote and pin one, and `cross-assistant-sessions.md` for reading, inventorying, taking over and resuming sessions of Claude Code, Codex, Kimi, Gemini and DeepSeek.

package/lib/core/panel.d.ts

@@ -87,6 +87,7 @@ export declare class AssistantSessionsPanel extends Widget {
      * the launch REACHED the server and was refused, and nothing retries it. */
     private _notifyLaunchError;
     private _logError;
+    /** `keepSame`: an answer equal to what is drawn leaves the rows in place. */
     private _fetch;
     private _toggleFavourite;
     /** The warning a deletion earns: with the trash setting on, a refused move
@@ -316,6 +317,13 @@ export declare class AssistantSessionsPanel extends Widget {
      * all. Returning null lets the popup fall back to its fork marker. */
     private _bgBadgeFor;
     private _startPolling;
+    /** The server says this assistant's sessions changed (ACC-CLI-227): read
+     * them through the poll's single-flight fetch. Unlike a poll tick it is
+     * never dropped. It waits for an open row context menu to close, and one
+     * that lands while a read is in flight reads once more after it, because
+     * that read may have been answered before the change. */
+    sessionsChanged(): void;
+    private _poll;
     private _stopPolling;
     private readonly _app;
     private readonly _descriptor;
@@ -375,9 +383,13 @@ export declare class AssistantSessionsPanel extends Widget {
     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. */
+    /** The poll's own in-flight tick. Only the poll and a pushed change read it
+     * - an explicit Refresh must always issue, however long the last poll is
+     * taking. */
     private _polling;
+    /** A pushed change waits for the context menu to close or for the read in
+     * flight to answer - see `sessionsChanged`. */
+    private _changeWaits;
     /** Listing requests sent, and the number of the newest one drawn - see
      * `_fetch`. */
     private _fetchSent;

package/lib/core/panel.js

@@ -40,6 +40,18 @@ const INLINE_BRANCH_LIMIT = 5;
  * exports no token, so its absence is something to ask the command registry
  * about at click time rather than a build-time dependency (ACC-LNCH-155). */
 const BASIC_TERMINAL_LAUNCH = 'basic-terminal:launch';
+/** What a delete says about the conversations the server kept because a live
+ * terminal runs them (ACC-SESS-57); empty when it kept none. */
+function keptCopy(liveIds) {
+    var _a;
+    const kept = (_a = liveIds === null || liveIds === void 0 ? void 0 : liveIds.length) !== null && _a !== void 0 ? _a : 0;
+    if (kept === 0) {
+        return '';
+    }
+    return kept === 1
+        ? 'One conversation was kept, because a live terminal runs it.'
+        : `${kept} conversations were kept, because live terminals run them.`;
+}
 export const DEFAULT_PRESENTATION_MODE = 'name';
 const SECTION_LABELS = {
     favourites: 'Favorites',
@@ -173,9 +185,13 @@ export class AssistantSessionsPanel extends Widget {
         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. */
+        /** The poll's own in-flight tick. Only the poll and a pushed change read it
+         * - an explicit Refresh must always issue, however long the last poll is
+         * taking. */
         this._polling = null;
+        /** A pushed change waits for the context menu to close or for the read in
+         * flight to answer - see `sessionsChanged`. */
+        this._changeWaits = false;
         /** Listing requests sent, and the number of the newest one drawn - see
          * `_fetch`. */
         this._fetchSent = 0;
@@ -633,7 +649,8 @@ export class AssistantSessionsPanel extends Widget {
         console.error(`${LOG_PREFIX}[${this._descriptor.id}]`, message);
     }
     // ------------------------------------------------------------------- data
-    async _fetch() {
+    /** `keepSame`: an answer equal to what is drawn leaves the rows in place. */
+    async _fetch(keepSame = false) {
         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).
@@ -647,10 +664,16 @@ export class AssistantSessionsPanel extends Widget {
         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; });
+        const 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();
+        // A redraw replaces every row, and the row a click is on with it
+        // (DEF-PANE-370-OWN-PUSH).
+        if (!keepSame ||
+            JSON.stringify(sessions) !== JSON.stringify(this._sessions)) {
+            this._sessions = sessions;
+            this._terminals.setSessions(this._sessions);
+            this._render();
+        }
         // Best-effort tinting; never let a colour failure break the fetch.
         void this._colours.load().then(() => this._terminals.reconcileColours());
     }
@@ -668,8 +691,9 @@ export class AssistantSessionsPanel extends Widget {
             });
             // 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);
+            // (DEF-PANE-351). When it answers what the star above drew, the rows
+            // stay: the star is redrawn once.
+            void this._fetch(true).catch(() => undefined);
         }
         catch (err) {
             session.favourite = !next; // roll back
@@ -737,14 +761,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') })
@@ -753,6 +807,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;
         }
@@ -760,6 +866,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
@@ -774,6 +881,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
@@ -784,9 +892,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.
@@ -795,6 +905,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;
@@ -808,11 +919,16 @@ 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;
-            message.textContent = `Removed ${data.removed_count} parallel session${data.removed_count === 1 ? '' : 's'}.`;
+            message.textContent = [
+                `Removed ${data.removed_count} parallel session${data.removed_count === 1 ? '' : 's'}.`,
+                keptCopy(data.live_ids)
+            ]
+                .filter(part => part)
+                .join(' ');
             // Refresh so the row's conversation count and menu label update.
             await this._fetch();
         }
@@ -1415,6 +1531,10 @@ export class AssistantSessionsPanel extends Widget {
             await this._colours.forget((_a = result.removed_ids) !== null && _a !== void 0 ? _a : sessionIds);
             // The kept listing names conversations that may have just gone.
             this._branchCache = null;
+            const kept = keptCopy(result.live_ids);
+            if (kept) {
+                Notification.info(kept, { autoClose: 4000 });
+            }
             return result.removed_count;
         }
         catch (err) {
@@ -2333,6 +2453,11 @@ export class AssistantSessionsPanel extends Widget {
             // callback still needs to read it. The field is overwritten on the next
             // contextmenu open.
             this._setActiveRow(null);
+            // A change pushed while the menu was open reads now. A microtask later,
+            // because the menu is still attached while this signal fires.
+            if (this._changeWaits) {
+                queueMicrotask(() => this.sessionsChanged());
+            }
         });
     }
     _menu(commands = this._commands) {
@@ -2611,13 +2736,36 @@ export class AssistantSessionsPanel extends Widget {
             if (this._polling !== null) {
                 return;
             }
-            this._polling = this._fetch()
-                .catch(err => this._showError(err))
-                .finally(() => {
-                this._polling = null;
-            });
+            this._poll();
         }, POLL_INTERVAL_MS);
     }
+    /** The server says this assistant's sessions changed (ACC-CLI-227): read
+     * them through the poll's single-flight fetch. Unlike a poll tick it is
+     * never dropped. It waits for an open row context menu to close, and one
+     * that lands while a read is in flight reads once more after it, because
+     * that read may have been answered before the change. */
+    sessionsChanged() {
+        if (this.isDisposed) {
+            return;
+        }
+        if (this._contextMenu.isAttached || this._polling !== null) {
+            this._changeWaits = true;
+            return;
+        }
+        this._poll();
+    }
+    _poll() {
+        // A read sent now answers every change pushed before it.
+        this._changeWaits = false;
+        this._polling = this._fetch()
+            .catch(err => this._showError(err))
+            .finally(() => {
+            this._polling = null;
+            if (this._changeWaits) {
+                this.sessionsChanged();
+            }
+        });
+    }
     _stopPolling() {
         if (this._pollHandle !== null) {
             window.clearInterval(this._pollHandle);

package/lib/core/request.d.ts

@@ -1,6 +1,11 @@
 import { ServerConnection } from '@jupyterlab/services';
 /** The server extension's API namespace. Every route lives under it. */
 export declare const API_NAMESPACE = "jupyterlab-ai-code-assistants-extension";
+/** This window's name, sent with every request in {@link WINDOW_HEADER}. The
+ * server names it in the push a change causes, and this window skips that
+ * push: its panel re-reads after every write it makes (DEF-PANE-370-OWN-PUSH). */
+export declare const WINDOW_ID: string;
+export declare const WINDOW_HEADER = "X-AI-Assistants-Window";
 /**
  * DEF-72: how long a single server call may run before the client gives up.
  *

package/lib/core/request.js

@@ -1,8 +1,14 @@
 import { URLExt } from '@jupyterlab/coreutils';
 import { ServerConnection } from '@jupyterlab/services';
+import { UUID } from '@lumino/coreutils';
 import { LOG_PREFIX } from './registry';
 /** The server extension's API namespace. Every route lives under it. */
 export const API_NAMESPACE = 'jupyterlab-ai-code-assistants-extension';
+/** This window's name, sent with every request in {@link WINDOW_HEADER}. The
+ * server names it in the push a change causes, and this window skips that
+ * push: its panel re-reads after every write it makes (DEF-PANE-370-OWN-PUSH). */
+export const WINDOW_ID = UUID.uuid4();
+export const WINDOW_HEADER = 'X-AI-Assistants-Window';
 /**
  * DEF-72: how long a single server call may run before the client gives up.
  *
@@ -68,6 +74,15 @@ export function isRequestTimeout(err) {
 export async function requestAPI(endPoint, serverSettings, init = {}) {
     var _a, _b;
     const requestUrl = URLExt.join(serverSettings.baseUrl, API_NAMESPACE, endPoint);
+    // shortcut: a `Headers` instance in `init.headers` would be dropped here; no
+    // caller passes one.
+    init = {
+        ...init,
+        headers: {
+            ...init.headers,
+            [WINDOW_HEADER]: WINDOW_ID
+        }
+    };
     // DEF-72: `ServerConnection.makeRequest` sets no deadline of its own, so
     // without this a wedged server holds the call for as long as the browser
     // will hold the socket. Hand-rolled rather than `AbortSignal.timeout`, which

package/lib/core/types.d.ts

@@ -163,8 +163,12 @@ export interface IDisposalReport {
     removed_ids: string[];
 }
 export type IRemoveResponse = IDisposalReport;
-export type ICleanupResponse = IDisposalReport;
-export type IDeleteSessionsResponse = IDisposalReport;
+/** A delete of chosen conversations also names the ones it kept because a
+ * live terminal runs them (ACC-SESS-57). */
+export interface IDeleteSessionsResponse extends IDisposalReport {
+    live_ids: string[];
+}
+export type ICleanupResponse = IDeleteSessionsResponse;
 export interface IBranch {
     session_id: string;
     file_mtime: number;