jupyterlab_ai_code_assistants_extension 1.2.271 → 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.js

@@ -737,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') })
@@ -753,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;
         }
@@ -760,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
@@ -774,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
@@ -784,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.
@@ -795,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;
@@ -808,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;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "jupyterlab_ai_code_assistants_extension",
-    "version": "1.2.271",
+    "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__/panel.spec.ts

@@ -154,7 +154,10 @@ beforeEach(async () => {
   // (DEF-30), so the GET goes out after the call rather than during it.
   // Cleared once it has, or it counts against the first test to look.
   await flush();
-  request.mockClear();
+  // Every case starts from the module factory's empty answer; `mockClear`
+  // alone left the previous case's implementation in place for the next one.
+  request.mockReset();
+  request.mockImplementation(() => Promise.resolve({}));
 });
 
 afterEach(async () => {
@@ -261,28 +264,52 @@ describe('DEF-51 - the destructive dialogs open with Cancel under the keyboard',
     pressEnter();
     await done;
 
-    // Cancelling stops before the branch fetch, so nothing is requested and no
-    // progress dialog is raised.
-    expect(request).not.toHaveBeenCalled();
+    // The question's own branches fetch has run; cancelling stops before the
+    // removal, so no DELETE is sent and no progress dialog is raised.
+    expect(
+      request.mock.calls.filter(call => call[3]?.method === 'DELETE')
+    ).toHaveLength(0);
     expect(
       document.querySelector('.jp-AiAssistantsPanel-cleanupBody')
     ).toBeNull();
   });
 
   it('Clean Up Parallel Sessions: Enter on the Remove button still cleans up', async () => {
-    // Same non-vacuity guard as above.
-    request.mockImplementation(() => Promise.resolve({ branches: [] }));
-    void ((panel as any)._cleanupParallel(
-      session({ extra_sessions: 3 })
-    ) as Promise<void>);
+    // Same non-vacuity guard as above: the harness can see the removal, so
+    // "no DELETE" above means the keyboard landed elsewhere and not that the
+    // probe is blind.
+    request.mockImplementation(() =>
+      Promise.resolve({
+        current: 'sid-proj',
+        total: 2,
+        branches: [
+          { session_id: 'sid-branch', file_mtime: 1, label: 'Branch' }
+        ],
+        removed_count: 1
+      })
+    );
+    const done = (panel as any)._cleanupParallel(
+      session({ name: 'proj', extra_sessions: 3 })
+    ) as Promise<void>;
     (await openButtons())[1].focus();
     pressEnter();
     await flush();
 
-    expect(request).toHaveBeenCalled();
+    const deletes = request.mock.calls.filter(
+      call => call[3]?.method === 'DELETE'
+    );
+    expect(deletes).toHaveLength(1);
+    expect(JSON.parse(deletes[0][3].body).session_ids).toEqual(['sid-branch']);
     expect(
       document.querySelector('.jp-AiAssistantsPanel-cleanupBody')
     ).not.toBeNull();
+    // The progress dialog's body is a Widget, which leaves showDialog no
+    // string to name it from, so the panel names it from the title.
+    expect(
+      document.querySelector('.jp-Dialog')!.getAttribute('aria-label')
+    ).toContain('Clean Up Parallel Sessions');
+    // Let the removal finish before the dialog is dismissed below.
+    await done;
   });
 });
 
@@ -2268,7 +2295,20 @@ describe('ACC-SESS-61, ACC-SESS-62 - what the destructive confirmations state',
   });
 
   it('ACC-SESS-62 - the cleanup confirmation states how many go and that one stays', async () => {
-    const row = session({ name: 'ledger-tools', extra_sessions: 3 });
+    // The fetched list is what the question counts: three branches despite a
+    // row that claims nine. It also gives Cancel a DELETE to withhold.
+    request.mockImplementationOnce(() =>
+      Promise.resolve({
+        current: 'sid-ledger-tools',
+        total: 4,
+        branches: [0, 1, 2].map(index => ({
+          session_id: `sid-branch-${index}`,
+          file_mtime: 1,
+          label: `Branch ${index}`
+        }))
+      })
+    );
+    const row = session({ name: 'ledger-tools', extra_sessions: 9 });
     const done = (panel as any)._cleanupParallel(row) as Promise<void>;
     await openButtons();
     const body = document.querySelector('.jp-Dialog-body')!.textContent ?? '';
@@ -2278,7 +2318,10 @@ describe('ACC-SESS-61, ACC-SESS-62 - what the destructive confirmations state',
     expect(body).toContain('current conversation is kept');
     pressEnter();
     await done;
-    expect(request).not.toHaveBeenCalled();
+    // Cancelling after the question's branches fetch sends no DELETE.
+    expect(
+      request.mock.calls.filter(call => call[3]?.method === 'DELETE')
+    ).toHaveLength(0);
   });
 
   it('ACC-SESS-62 - one parallel session is counted in the singular', async () => {
@@ -2293,6 +2336,253 @@ describe('ACC-SESS-61, ACC-SESS-62 - what the destructive confirmations state',
   });
 });
 
+describe('ACC-PANE-221, ACC-PANE-222 - the cleanup confirmation warning and hint', () => {
+  const HOUR = 3_600_000;
+
+  const openButtons = async (): Promise<HTMLButtonElement[]> => {
+    await flush();
+    const dialog = document.querySelector('.jp-Dialog');
+    expect(dialog).not.toBeNull();
+    return Array.from(
+      dialog!.querySelectorAll<HTMLButtonElement>('.jp-Dialog-button')
+    );
+  };
+
+  const pressEnter = (): void => {
+    document
+      .querySelector('.jp-Dialog')!
+      .dispatchEvent(
+        new KeyboardEvent('keydown', { key: 'Enter', bubbles: true })
+      );
+  };
+
+  /** The branch list a provider answers with: the kept conversation is not in
+   * it, exactly as `list_branches` returns it. */
+  const branches = (mtimes: number[]): any => ({
+    current: 'sid-kept',
+    total: mtimes.length + 1,
+    branches: mtimes.map((file_mtime, index) => ({
+      session_id: `sid-branch-${index}`,
+      file_mtime,
+      label: `Branch ${index}`
+    }))
+  });
+
+  it('opens at once and warns when the branch list lands later', async () => {
+    const now = Date.now();
+    let release: ((value: any) => void) | undefined;
+    // The request layer allows 60 s: the question must not wait for it.
+    request.mockImplementationOnce(
+      () => new Promise(resolve => (release = resolve))
+    );
+    const row = session({
+      name: 'ledger-tools',
+      extra_sessions: 2,
+      file_mtime: now - 2 * HOUR
+    });
+
+    const done = (panel as any)._cleanupParallel(row) as Promise<void>;
+    await openButtons();
+    // Up already, on the row's own count.
+    expect(document.querySelector('.jp-Dialog-body')!.textContent).toContain(
+      '2 parallel sessions'
+    );
+    // The restated question is announced politely.
+    expect(
+      document.querySelector('.jp-Dialog-body p')!.getAttribute('role')
+    ).toBe('status');
+    // The Widget body leaves showDialog no string to name the dialog from, so
+    // the name is set here and carries the question on screen.
+    expect(
+      document.querySelector('.jp-Dialog')!.getAttribute('aria-label')
+    ).toContain('Remove 2 parallel sessions from "ledger-tools"?');
+
+    // The list lands while the dialog is open: the count becomes the list's
+    // and the newer conversation adds the warning.
+    release!(branches([now - HOUR]));
+    await flush();
+    expect(document.querySelector('.jp-Dialog-body')!.textContent).toContain(
+      'Remove 1 parallel session from'
+    );
+    const warning = document.querySelector(
+      '.jp-AiAssistantsPanel-cleanupWarning'
+    )!;
+    expect(warning.textContent).toBe(
+      '1 parallel session was active after the one kept.'
+    );
+    // The warning is announced, and the dialog's name follows the restated
+    // question and the warning.
+    expect(warning.getAttribute('role')).toBe('alert');
+    const label = document
+      .querySelector('.jp-Dialog')!
+      .getAttribute('aria-label');
+    expect(label).toContain('Remove 1 parallel session from "ledger-tools"?');
+    expect(label).toContain(warning.textContent!);
+
+    pressEnter();
+    await done;
+  });
+
+  it('states the empty outcome and refreshes the list when the fetched list is empty', async () => {
+    const now = Date.now();
+    let release: ((value: any) => void) | undefined;
+    request.mockImplementationOnce(
+      () => new Promise(resolve => (release = resolve))
+    );
+    const row = session({
+      name: 'ledger-tools',
+      extra_sessions: 2,
+      file_mtime: now - 2 * HOUR
+    });
+
+    const done = (panel as any)._cleanupParallel(row) as Promise<void>;
+    await openButtons();
+    // The row is a poll old and a second client cleaned the project: the
+    // confirmation ends through the accept path, whose zero-id guard states
+    // the empty outcome, instead of restating "Remove 0 parallel sessions"
+    // with the red Remove still offered (DEF-PANE-364, DEF-PANE-365).
+    release!(branches([]));
+    await done;
+    await flush();
+
+    // The outcome dialog, not a bare dismissal: the user is told why.
+    expect(document.querySelector('.jp-Dialog-body')!.textContent).toContain(
+      'Nothing left to clean up.'
+    );
+    expect(
+      Array.from(
+        document.querySelectorAll<HTMLButtonElement>('.jp-Dialog-button')
+      ).map(button => button.textContent)
+    ).toEqual(['Close']);
+    // The dialog's name carries the outcome statement, so a screen reader
+    // hears why the confirmation closed, and the message is a status region
+    // for an outcome that lands after the dialog has been read
+    // (DEF-PANE-366-EMPTY-OUTCOME).
+    expect(
+      document.querySelector('.jp-Dialog')!.getAttribute('aria-label')
+    ).toContain('Nothing left to clean up.');
+    expect(
+      document
+        .querySelector('.jp-AiAssistantsPanel-cleanupMessage')!
+        .getAttribute('role')
+    ).toBe('status');
+    // The branches fetch only: nothing was deleted.
+    expect(
+      request.mock.calls.filter(call => call[3]?.method === 'DELETE')
+    ).toHaveLength(0);
+    // The guard refreshed the list once, after the fetch it answered.
+    const paths = request.mock.calls.map(call => call[1]);
+    expect(paths.filter(path => path === 'branches')).toHaveLength(1);
+    expect(paths.filter(path => path === 'sessions')).toHaveLength(1);
+    expect(paths.indexOf('sessions')).toBeGreaterThan(
+      paths.indexOf('branches')
+    );
+  });
+
+  it('warns when a conversation it removes was active after the one kept', async () => {
+    const now = Date.now();
+    const row = session({
+      name: 'ledger-tools',
+      extra_sessions: 2,
+      file_mtime: now - 2 * HOUR
+    });
+    request.mockResolvedValueOnce(branches([now - HOUR, now - 3 * HOUR]));
+
+    const done = (panel as any)._cleanupParallel(row) as Promise<void>;
+    await openButtons();
+
+    const warning = document.querySelector(
+      '.jp-AiAssistantsPanel-cleanupWarning'
+    );
+    expect(warning).not.toBeNull();
+    // It names the one conversation that was newer, not the whole list.
+    expect(warning!.textContent).toContain('1 parallel session was');
+    // The question counts the fetched list, which is the list the removal
+    // deletes - not the row's count from an older poll.
+    expect(document.querySelector('.jp-Dialog-body')!.textContent).toContain(
+      '2 parallel sessions'
+    );
+    pressEnter();
+    await done;
+  });
+
+  it('does not warn when every conversation it removes is older or equal', async () => {
+    const now = Date.now();
+    const row = session({
+      name: 'ledger-tools',
+      extra_sessions: 2,
+      file_mtime: now - 2 * HOUR
+    });
+    // Equal is the boundary: only a LATER activity is a warning.
+    request.mockResolvedValueOnce(branches([now - 2 * HOUR, now - 3 * HOUR]));
+
+    const done = (panel as any)._cleanupParallel(row) as Promise<void>;
+    await openButtons();
+
+    expect(
+      document.querySelector('.jp-AiAssistantsPanel-cleanupWarning')
+    ).toBeNull();
+    pressEnter();
+    await done;
+  });
+
+  it('states its hint in at most twelve words, in both disposal settings', async () => {
+    const now = Date.now();
+    const row = session({ name: 'ledger-tools', extra_sessions: 1 });
+    request.mockResolvedValueOnce(branches([now - 3 * HOUR]));
+
+    let done = (panel as any)._cleanupParallel(row) as Promise<void>;
+    await openButtons();
+    let hint = document.querySelector(
+      '.jp-AiAssistantsPanel-cleanupHint'
+    )!.textContent!;
+    expect(hint.trim().split(/\s+/).length).toBeLessThanOrEqual(12);
+    expect(hint).toContain('go to the trash');
+    // The hint promises the trash; the caution names the refusal that deletes
+    // permanently.
+    expect(
+      document.querySelector('.jp-AiAssistantsPanel-cleanupCaution')!
+        .textContent
+    ).toContain('A refused trash move deletes permanently');
+    pressEnter();
+    await done;
+
+    (panel as any)._deleteToTrash = false;
+    request.mockResolvedValueOnce(branches([now - 3 * HOUR]));
+    done = (panel as any)._cleanupParallel(row) as Promise<void>;
+    await openButtons();
+    hint = document.querySelector(
+      '.jp-AiAssistantsPanel-cleanupHint'
+    )!.textContent!;
+    expect(hint.trim().split(/\s+/).length).toBeLessThanOrEqual(12);
+    expect(hint).toContain('deleted permanently');
+    // The caution is not the hint: it stays visible on its own.
+    expect(
+      document.querySelector('.jp-AiAssistantsPanel-cleanupCaution')!
+        .textContent
+    ).toContain('cannot be undone');
+    pressEnter();
+    await done;
+  });
+
+  it('shows the question without a warning when the fetch fails', async () => {
+    request.mockRejectedValueOnce(new Error('offline'));
+    const row = session({ name: 'ledger-tools', extra_sessions: 3 });
+
+    const done = (panel as any)._cleanupParallel(row) as Promise<void>;
+    await openButtons();
+
+    expect(
+      document.querySelector('.jp-AiAssistantsPanel-cleanupWarning')
+    ).toBeNull();
+    expect(document.querySelector('.jp-Dialog-body')!.textContent).toContain(
+      '3 parallel sessions'
+    );
+    pressEnter();
+    await done;
+  });
+});
+
 describe('ACC-PANE-35..45 - what a row and a section show', () => {
   const MINUTE = 60_000;
   const HOUR = 3_600_000;

package/src/core/panel.ts

@@ -836,14 +836,44 @@ export class AssistantSessionsPanel extends Widget {
   }
 
   private async _cleanupParallel(session: ISession): Promise<void> {
-    const extra = session.extra_sessions;
     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: number): void => {
+      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: HTMLElement | null = null;
+    const confirmDialog = new Dialog<unknown>({
+      title,
+      body: confirmBody,
       buttons: [
         Dialog.cancelButton(),
         Dialog.warnButton({ label: this._trans.__('Remove') })
@@ -852,6 +882,66 @@ 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 = (): void => {
+      confirmDialog.node.setAttribute(
+        'aria-label',
+        [
+          title,
+          question.textContent ?? '',
+          hint.textContent ?? '',
+          caution.textContent ?? '',
+          warning?.textContent ?? ''
+        ]
+          .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?.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;
     }
@@ -861,6 +951,7 @@ export class AssistantSessionsPanel extends Widget {
 
     const message = document.createElement('div');
     message.className = 'jp-AiAssistantsPanel-cleanupMessage';
+    message.setAttribute('role', 'status');
     message.textContent = `Removing ${extra} parallel session${
       extra === 1 ? '' : 's'
     }...`;
@@ -879,6 +970,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
@@ -890,9 +982,12 @@ export class AssistantSessionsPanel extends Widget {
 
     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 =
+        (await branchesReady) ?? (await this._fetchBranches(session));
+      const ids = (fetched?.branches ?? []).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.
@@ -901,6 +996,10 @@ export class AssistantSessionsPanel extends Widget {
         // to remove N.
         bar.remove();
         message.textContent = 'Nothing left to clean up.';
+        dialog.node.setAttribute(
+          'aria-label',
+          `${title}. ${message.textContent ?? ''}`
+        );
         this._branchCache = null;
         await this._fetch();
         return;

package/style/base.css

@@ -683,6 +683,35 @@ body[data-jp-theme-light='true'] .jp-AiAssistantsPanel-dotHalo {
   color: var(--jp-error-color1);
 }
 
+/* The cleanup confirmation's question, hint, caution and warning. The warning
+   box is separate from the body text because it answers one question - is a
+   conversation this removal deletes newer than the one kept? - and it uses the
+   warning colour, not the error colour: the removal is still the user's call.
+   The tint is mixed with the surface colour, so both themes keep the text
+   readable. */
+.jp-AiAssistantsPanel-cleanupConfirm {
+  display: flex;
+  flex-direction: column;
+  gap: 8px;
+  max-width: 440px;
+}
+
+.jp-AiAssistantsPanel-cleanupConfirm p {
+  margin: 0;
+}
+
+.jp-AiAssistantsPanel-cleanupWarning {
+  padding: 6px 8px;
+  border-left: 3px solid var(--jp-warn-color1);
+  border-radius: 2px;
+  background: color-mix(
+    in srgb,
+    var(--jp-warn-color1) 12%,
+    var(--jp-layout-color1)
+  );
+  color: var(--jp-ui-font-color1);
+}
+
 .jp-AiAssistantsPanel-row.jp-mod-busy {
   opacity: 0.55;
   pointer-events: none;