jupyterlab_ai_code_assistants_extension 1.2.288 → 1.2.299

package/lib/core/panel.d.ts

@@ -90,11 +90,6 @@ export declare class AssistantSessionsPanel extends Widget {
     /** `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
-     * may remove the conversations permanently or leave them in place, so
-     * neither the verb nor the note may promise one outcome. */
-    private get _irreversibleNote();
-    private get _disposalVerb();
     private _removeProject;
     private _cleanupParallel;
     /** This provider's launch-mode token for one action - see

package/lib/core/panel.js

@@ -1,4 +1,4 @@
-import { Clipboard, Dialog, InputDialog, Notification, showDialog } from '@jupyterlab/apputils';
+import { Clipboard, Dialog, InputDialog, Notification } from '@jupyterlab/apputils';
 import { MenuSvg, closeIcon, copyIcon, editIcon, folderIcon, terminalIcon } from '@jupyterlab/ui-components';
 import { nullTranslator } from '@jupyterlab/translation';
 import { CommandRegistry } from '@lumino/commands';
@@ -701,27 +701,33 @@ export class AssistantSessionsPanel extends Widget {
             this._showActionError('Could not toggle favorite - try again.', err);
         }
     }
-    /** The warning a deletion earns: with the trash setting on, a refused move
-     * may remove the conversations permanently or leave them in place, so
-     * neither the verb nor the note may promise one outcome. */
-    get _irreversibleNote() {
-        return this._deleteToTrash
-            ? ' A permanent removal cannot be undone.'
-            : ' This cannot be undone.';
-    }
-    get _disposalVerb() {
-        return this._deleteToTrash
-            ? 'moved to the trash when the system accepts them; a refused move may remove them permanently or leave them in place'
-            : 'deleted permanently';
-    }
     async _removeProject(session) {
         var _a;
         const name = this._lookupName(session);
-        const confirm = await showDialog({
-            title: `Remove from ${this._descriptor.label}`,
-            body: `Remove "${name}" from ${this._descriptor.label}? This drops the ` +
-                `entire project history and every conversation it holds - ` +
-                `${this._disposalVerb}.${this._irreversibleNote}`,
+        const title = `Remove from ${this._descriptor.label}`;
+        // The consequence only, in two lines: the question and the outcome, then
+        // the permanent-deletion refusal on its own caution line
+        // (DEF-PANE-371-DIALOG-TEXT).
+        const outcome = this._deleteToTrash
+            ? `Remove "${name}"? Every conversation in it goes to the trash.`
+            : `Remove "${name}"? Every conversation in it is deleted permanently.`;
+        const caution = this._deleteToTrash
+            ? 'A refused move deletes permanently.'
+            : '';
+        const body = new Widget();
+        body.node.className = 'jp-AiAssistantsPanel-removeConfirm';
+        const question = document.createElement('p');
+        question.textContent = outcome;
+        body.node.appendChild(question);
+        if (caution) {
+            const line = document.createElement('p');
+            line.className = 'jp-AiAssistantsPanel-removeCaution';
+            line.textContent = caution;
+            body.node.appendChild(line);
+        }
+        const dialog = new Dialog({
+            title,
+            body,
             buttons: [
                 Dialog.cancelButton(),
                 Dialog.warnButton({ label: this._trans.__('Remove') })
@@ -734,6 +740,9 @@ export class AssistantSessionsPanel extends Widget {
             defaultButton: 0,
             renderer: dialogRenderer
         });
+        // A Widget body leaves the Dialog no string to name itself from.
+        dialog.node.setAttribute('aria-label', [title, outcome, caution].filter(part => part).join(' '));
+        const confirm = await dialog.launch();
         if (!confirm.button.accept) {
             return;
         }
@@ -777,23 +786,23 @@ export class AssistantSessionsPanel extends Widget {
         };
         askCount(extra);
         confirmBody.node.appendChild(question);
-        // One sentence, twelve words or fewer: what happens, not the detail.
+        // The second line states what happens to the rest: the count, the short
+        // ids once the branch list names them, and the disposal the setting chose.
         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.';
+        // Announced when restated with the short ids; an aria-label change is not.
+        hint.setAttribute('role', 'status');
+        const stateHint = (ids) => {
+            const shortIds = ids === null || ids === void 0 ? void 0 : ids.map(id => shortSessionId(id, this._descriptor.sessionIdPrefix));
+            hint.textContent =
+                `Remaining ${extra} session${extra === 1 ? '' : 's'}` +
+                    ((shortIds === null || shortIds === void 0 ? void 0 : shortIds.length) ? ` ${shortIds.join(', ')}` : '') +
+                    (this._deleteToTrash
+                        ? ' will be removed.'
+                        : ' will be deleted permanently.');
+        };
+        stateHint(null);
         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({
@@ -807,29 +816,129 @@ 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.
+        // Scopes the armed style in base.css to this one dialog.
+        confirmDialog.addClass('jp-AiAssistantsPanel-cleanupDialog');
+        // The Dialog names itself only when its body is a string, and this body is
+        // a Widget: name it here, and again when the question and hint are
+        // restated and the warning joins it.
         const nameDialog = () => {
-            var _a, _b, _c, _d;
+            var _a, _b, _c;
             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 : ''
+                (_c = warning === null || warning === void 0 ? void 0 : warning.textContent) !== null && _c !== void 0 ? _c : ''
             ]
                 .filter(part => part)
                 .join(' '));
         };
         nameDialog();
+        // The house two-step destructive action (design-language.md, "Two-step
+        // destructive action"; the branch popup's Delete is the shipped form):
+        // while the newer state is unknown or newer, the accept button arms on the
+        // first activation and removes on the second, the arm lapsing after 4 s.
+        // It starts required: the branch fetch that decides whether a removal is
+        // safe is still out when the dialog opens.
+        let armRequired = true;
+        let armed = false;
+        let armTimer = 0;
+        // The arming activation's event.timeStamp, which the confirming one is
+        // measured against.
+        let armedAt = 0;
+        /** Find and relabel the accept button. The Dialog keeps its button nodes
+         * private and puts the label in a child whose aria-label overrides its
+         * text, so both are set. */
+        const updateAccept = () => {
+            const button = confirmDialog.node.querySelector('.jp-mod-accept');
+            const label = button === null || button === void 0 ? void 0 : button.querySelector('.jp-Dialog-buttonLabel');
+            if (!button || !label) {
+                return;
+            }
+            const text = armed
+                ? this._trans.__('Confirm remove %1', extra)
+                : armRequired
+                    ? this._trans.__('Remove (%1)', extra)
+                    : this._trans.__('Remove');
+            label.textContent = text;
+            label.setAttribute('aria-label', text);
+            button.classList.toggle('jp-mod-armed', armed);
+        };
+        const disarm = () => {
+            armed = false;
+            window.clearTimeout(armTimer);
+        };
+        /** Consume one accept activation. True means it only armed, or was the
+         * ignored half of a double-click, and the Dialog must not resolve; false
+         * lets the Dialog's own handler resolve it. */
+        const activate = (event) => {
+            if (!armRequired) {
+                return false;
+            }
+            // The second click of a double-click is not a confirmation (DEF-PANE-336):
+            // a multi-click within 600 ms of arming is ignored. A later click
+            // confirms whatever its detail, since the OS double-click interval can
+            // be longer than the user's pause (DEF-PANE-338).
+            if (armed && event.detail > 1 && event.timeStamp - armedAt < 600) {
+                return true;
+            }
+            if (!armed) {
+                armed = true;
+                armedAt = event.timeStamp;
+                window.clearTimeout(armTimer);
+                armTimer = window.setTimeout(() => {
+                    disarm();
+                    updateAccept();
+                }, 4000);
+                updateAccept();
+                return true;
+            }
+            disarm();
+            return false;
+        };
+        // Registered before launch(): the Dialog attaches its own capture
+        // listeners on this same node when launch() attaches it, so these run
+        // first and can swallow an activation that must only arm. Space arrives
+        // as a click; Enter arrives as a keydown the Dialog would otherwise
+        // resolve from, so both are intercepted here.
+        confirmDialog.node.addEventListener('click', event => {
+            const button = confirmDialog.node.querySelector('.jp-mod-accept');
+            if (!button || !button.contains(event.target)) {
+                return;
+            }
+            if (activate(event)) {
+                event.stopImmediatePropagation();
+                event.preventDefault();
+            }
+        }, true);
+        confirmDialog.node.addEventListener('keydown', event => {
+            if (event.key !== 'Enter') {
+                return;
+            }
+            const accept = confirmDialog.node.querySelector('.jp-mod-accept');
+            if (!accept || document.activeElement !== accept) {
+                return;
+            }
+            // A held key's auto-repeat is not a second press (DEF-PANE-347): it
+            // must neither confirm nor arm, and consuming it stops the Dialog's
+            // own Enter handler from resolving the accept.
+            if (event.repeat) {
+                event.stopImmediatePropagation();
+                event.preventDefault();
+                return;
+            }
+            if (activate(event)) {
+                event.stopImmediatePropagation();
+                event.preventDefault();
+            }
+        }, true);
+        updateAccept();
         // 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.
+        // question and hint state its length and ids, and a conversation newer
+        // than the kept one adds the warning, drawn last so it reads after the
+        // hint. The same list is what the removal deletes. A failed fetch leaves
+        // the question as the row reported it, with no ids and 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) {
@@ -844,6 +953,7 @@ export class AssistantSessionsPanel extends Widget {
             else if (list) {
                 extra = list.length;
                 askCount(extra);
+                stateHint(list.map(branch => branch.session_id));
                 const newer = list.filter(branch => branch.file_mtime > session.file_mtime).length;
                 if (newer > 0) {
                     warning = document.createElement('div');
@@ -851,9 +961,16 @@ export class AssistantSessionsPanel extends Widget {
                     warning.setAttribute('role', 'alert');
                     warning.textContent =
                         `${newer} parallel session${newer === 1 ? ' was' : 's were'} ` +
-                            'active after the one kept.';
+                            'active after the current session.';
                     confirmBody.node.appendChild(warning);
                 }
+                // The list just decided what the button acts on: an arm given while
+                // it was pending could confirm a different set, so drop it and
+                // restate the label with the fetched count. With no newer branch the
+                // button returns to the one-click Remove.
+                disarm();
+                armRequired = newer > 0;
+                updateAccept();
                 nameDialog();
             }
             return fetched;

package/lib/core/popup.js

@@ -91,7 +91,7 @@ export function showManageSessionsPopup(options) {
     deleteBtn.type = 'button';
     deleteBtn.className = 'jp-AiAssistantsPanel-branchDelete';
     deleteBtn.title = options.deleteToTrash
-        ? 'Deleted conversations move to the trash when the system accepts them; a refused move may remove them permanently or leave them in place'
+        ? 'Deleted conversations go to the trash; a refused move deletes permanently.'
         : 'Deleted conversations are removed permanently';
     footer.appendChild(deleteBtn);
     // Plain visual counter (selection, or the last action), beside the button

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "jupyterlab_ai_code_assistants_extension",
-    "version": "1.2.288",
+    "version": "1.2.299",
     "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

@@ -220,19 +220,39 @@ describe('DEF-51 - the destructive dialogs open with Cancel under the keyboard',
     // when no trash accepts the move.
     let done = (panel as any)._removeProject(session()) as Promise<void>;
     await openButtons();
-    let body = document.querySelector('.jp-Dialog-body')!.textContent ?? '';
-    expect(body).toContain(
-      'moved to the trash when the system accepts them; a refused move may remove them permanently or leave them in place'
+    // A Widget body leaves the Dialog no string to name itself from, so the
+    // aria-label is the dialog's only accessible name - the whole of it.
+    const label = document
+      .querySelector('.jp-Dialog')!
+      .getAttribute('aria-label')!;
+    expect(label).toContain('Remove from Testbed');
+    expect(label).toContain(
+      'Remove "proj"? Every conversation in it goes to the trash.'
+    );
+    expect(label).toContain('A refused move deletes permanently.');
+    let lines = Array.from(document.querySelectorAll('.jp-Dialog-body p')).map(
+      line => line.textContent ?? ''
     );
-    expect(body).toContain('A permanent removal cannot be undone');
+    expect(lines).toEqual([
+      'Remove "proj"? Every conversation in it goes to the trash.',
+      'A refused move deletes permanently.'
+    ]);
+    // The body states its outcome in at most twenty words, the caution in at
+    // most twelve (DEF-PANE-371-DIALOG-TEXT).
+    expect(lines[0].trim().split(/\s+/).length).toBeLessThanOrEqual(20);
+    expect(lines[1].trim().split(/\s+/).length).toBeLessThanOrEqual(12);
     pressEnter();
     await done;
 
     (panel as any)._deleteToTrash = false;
     done = (panel as any)._removeProject(session()) as Promise<void>;
     await openButtons();
-    body = document.querySelector('.jp-Dialog-body')!.textContent ?? '';
-    expect(body).toContain('deleted permanently. This cannot be undone.');
+    lines = Array.from(document.querySelectorAll('.jp-Dialog-body p')).map(
+      line => line.textContent ?? ''
+    );
+    expect(lines).toEqual([
+      'Remove "proj"? Every conversation in it is deleted permanently.'
+    ]);
     pressEnter();
     await done;
   });
@@ -258,7 +278,10 @@ describe('DEF-51 - the destructive dialogs open with Cancel under the keyboard',
     ) as Promise<void>;
     const buttons = await openButtons();
 
-    expect(buttons.map(b => b.textContent)).toEqual(['Cancel', 'Remove']);
+    // The branch fetch has answered without a list, so the newer state stays
+    // unknown and the accept button keeps its arming label - and Cancel is
+    // still the default the fresh dialog puts under the keyboard.
+    expect(buttons.map(b => b.textContent)).toEqual(['Cancel', 'Remove (3)']);
     expect(document.activeElement).toBe(buttons[0]);
 
     pressEnter();
@@ -2286,23 +2309,25 @@ describe('ACC-SESS-61, ACC-SESS-62 - what the destructive confirmations state',
     const body = document.querySelector('.jp-Dialog-body')!.textContent ?? '';
 
     // The name, not just the word "project": two rows differ only by it, and
-    // this dialog drops an entire history.
+    // this dialog drops every conversation in it.
     expect(body).toContain('ledger-tools');
-    expect(body).toContain('entire project history');
+    expect(body).toContain('Every conversation in it goes to the trash');
     pressEnter();
     await done;
     expect(request).not.toHaveBeenCalled();
   });
 
-  it('ACC-SESS-62 - the cleanup confirmation states how many go and that one stays', async () => {
+  it('ACC-SESS-62 - the cleanup confirmation names the three removed sessions by short id', async () => {
     // The fetched list is what the question counts: three branches despite a
-    // row that claims nine. It also gives Cancel a DELETE to withhold.
+    // row that claims nine. It also gives Cancel a DELETE to withhold. The
+    // ids differ in their first eight characters, so each short id names one
+    // conversation.
     request.mockImplementationOnce(() =>
       Promise.resolve({
         current: 'sid-ledger-tools',
         total: 4,
-        branches: [0, 1, 2].map(index => ({
-          session_id: `sid-branch-${index}`,
+        branches: ['alpha', 'bravo', 'charlie'].map((name, index) => ({
+          session_id: `sess-${name}`,
           file_mtime: 1,
           label: `Branch ${index}`
         }))
@@ -2315,7 +2340,9 @@ describe('ACC-SESS-61, ACC-SESS-62 - what the destructive confirmations state',
 
     expect(body).toContain('3 parallel sessions');
     expect(body).toContain('ledger-tools');
-    expect(body).toContain('current conversation is kept');
+    expect(body).toContain(
+      'Remaining 3 sessions sess-alp, sess-bra, sess-cha will be removed.'
+    );
     pressEnter();
     await done;
     // Cancelling after the question's branches fetch sends no DELETE.
@@ -2391,6 +2418,10 @@ describe('ACC-PANE-221, ACC-PANE-222 - the cleanup confirmation warning and hint
     expect(
       document.querySelector('.jp-Dialog-body p')!.getAttribute('role')
     ).toBe('status');
+    // The hint is a live region too, because the fetch restates it with the
+    // short ids (DEF-PANE-374-HINT-ANNOUNCE).
+    const hint = document.querySelector('.jp-AiAssistantsPanel-cleanupHint')!;
+    expect(hint.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(
@@ -2408,8 +2439,12 @@ describe('ACC-PANE-221, ACC-PANE-222 - the cleanup confirmation warning and hint
       '.jp-AiAssistantsPanel-cleanupWarning'
     )!;
     expect(warning.textContent).toBe(
-      '1 parallel session was active after the one kept.'
+      '1 parallel session was active after the current session.'
     );
+    // The restatement kept the hint a live region and put the ids in it, so
+    // the change is announced.
+    expect(hint.getAttribute('role')).toBe('status');
+    expect(hint.textContent).toContain('sid-bran');
     // The warning is announced, and the dialog's name follows the restated
     // question and the warning.
     expect(warning.getAttribute('role')).toBe('alert');
@@ -2479,7 +2514,7 @@ describe('ACC-PANE-221, ACC-PANE-222 - the cleanup confirmation warning and hint
     );
   });
 
-  it('warns when a conversation it removes was active after the one kept', async () => {
+  it('warns when a conversation it removes was active after the current session', async () => {
     const now = Date.now();
     const row = session({
       name: 'ledger-tools',
@@ -2526,7 +2561,7 @@ describe('ACC-PANE-221, ACC-PANE-222 - the cleanup confirmation warning and hint
     await done;
   });
 
-  it('states its hint in at most twelve words, in both disposal settings', async () => {
+  it('lists the sessions it removes by short id in both disposal settings', async () => {
     const now = Date.now();
     const row = session({ name: 'ledger-tools', extra_sessions: 1 });
     request.mockResolvedValueOnce(branches([now - 3 * HOUR]));
@@ -2536,14 +2571,30 @@ describe('ACC-PANE-221, ACC-PANE-222 - the cleanup confirmation warning and hint
     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.
+    // The fetched branch is `sid-branch-0`; its short id is its first eight
+    // characters, which for Claude is the whole display id.
+    expect(hint).toBe('Remaining 1 session sid-bran will be removed.');
+    // A live region from creation: the restatement with the ids is announced
+    // (DEF-PANE-374-HINT-ANNOUNCE).
     expect(
-      document.querySelector('.jp-AiAssistantsPanel-cleanupCaution')!
-        .textContent
-    ).toContain('A refused trash move deletes permanently');
+      document
+        .querySelector('.jp-AiAssistantsPanel-cleanupHint')!
+        .getAttribute('role')
+    ).toBe('status');
+    // The caution line is gone from the confirmation entirely.
+    expect(
+      document.querySelector('.jp-AiAssistantsPanel-cleanupCaution')
+    ).toBeNull();
+    pressEnter();
+    await done;
+
+    // A failed fetch leaves no ids known: the hint states the count alone.
+    request.mockRejectedValueOnce(new Error('offline'));
+    done = (panel as any)._cleanupParallel(row) as Promise<void>;
+    await openButtons();
+    expect(
+      document.querySelector('.jp-AiAssistantsPanel-cleanupHint')!.textContent
+    ).toBe('Remaining 1 session will be removed.');
     pressEnter();
     await done;
 
@@ -2554,13 +2605,18 @@ describe('ACC-PANE-221, ACC-PANE-222 - the cleanup confirmation warning and hint
     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(hint).toBe(
+      'Remaining 1 session sid-bran will be deleted permanently.'
+    );
+    // The live region holds with the trash off as well.
     expect(
-      document.querySelector('.jp-AiAssistantsPanel-cleanupCaution')!
-        .textContent
-    ).toContain('cannot be undone');
+      document
+        .querySelector('.jp-AiAssistantsPanel-cleanupHint')!
+        .getAttribute('role')
+    ).toBe('status');
+    expect(
+      document.querySelector('.jp-AiAssistantsPanel-cleanupCaution')
+    ).toBeNull();
     pressEnter();
     await done;
   });
@@ -2583,6 +2639,379 @@ describe('ACC-PANE-221, ACC-PANE-222 - the cleanup confirmation warning and hint
   });
 });
 
+// ------------------------------------------- ACC-PANE-233..236 - arming Remove
+
+describe('ACC-PANE-233..236 - the cleanup confirmation arms Remove while the newer state is unknown or newer', () => {
+  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')
+    );
+  };
+
+  /** The label element, whose aria-label is the part of the button's
+   * accessible name that overrides its text. */
+  const labelOf = (button: HTMLButtonElement): HTMLDivElement =>
+    button.querySelector('.jp-Dialog-buttonLabel') as HTMLDivElement;
+
+  /** Dispatch a click with a chosen detail and timeStamp, so the double-click
+   * guard is exercised without a 600 ms wait. */
+  const click = (
+    button: HTMLButtonElement,
+    detail = 1,
+    timeStamp?: number
+  ): void => {
+    const event = new MouseEvent('click', {
+      bubbles: true,
+      cancelable: true,
+      detail
+    });
+    if (timeStamp !== undefined) {
+      Object.defineProperty(event, 'timeStamp', { value: timeStamp });
+    }
+    button.dispatchEvent(event);
+  };
+
+  /** Dispatch Enter on the dialog and return the event, so a caller can
+   * assert the handler consumed the browser's default activation. */
+  const pressEnter = (repeat = false): KeyboardEvent => {
+    const event = new KeyboardEvent('keydown', {
+      key: 'Enter',
+      repeat,
+      bubbles: true,
+      cancelable: true
+    });
+    document.querySelector('.jp-Dialog')!.dispatchEvent(event);
+    return event;
+  };
+
+  const deletes = (): any[] =>
+    request.mock.calls.filter(call => call[3]?.method === 'DELETE');
+
+  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}`
+    }))
+  });
+
+  /** Answer the branch fetch with this list and the DELETE with the same
+   * conversations removed; every other route answers empty. */
+  const serve = (mtimes: number[]): void => {
+    request.mockImplementation(
+      (_id: string, path: string, _s: unknown, init?: any) =>
+        Promise.resolve(
+          init?.method === 'DELETE'
+            ? {
+                removed_count: mtimes.length,
+                removed_ids: mtimes.map((_m, index) => `sid-branch-${index}`),
+                live_ids: []
+              }
+            : path === 'branches'
+              ? branches(mtimes)
+              : {}
+        )
+    );
+  };
+
+  const row = (extra_sessions: number, file_mtime: number): ISession =>
+    session({ name: 'ledger-tools', extra_sessions, file_mtime });
+
+  const closeProgress = async (): Promise<void> => {
+    Array.from(
+      document.querySelectorAll<HTMLButtonElement>('.jp-Dialog-button')
+    )
+      .find(button => button.textContent === 'Close')!
+      .click();
+    await flush();
+  };
+
+  it('ACC-PANE-233 - Remove arms to Confirm remove when the warning shows, and the second activation removes', async () => {
+    const now = Date.now();
+    serve([now - HOUR, now - 3 * HOUR]);
+    const done = (panel as any)._cleanupParallel(
+      row(2, now - 2 * HOUR)
+    ) as Promise<void>;
+    const buttons = await openButtons();
+
+    expect(
+      document.querySelector('.jp-AiAssistantsPanel-cleanupWarning')
+    ).not.toBeNull();
+    expect(buttons[1].textContent).toBe('Remove (2)');
+
+    click(buttons[1]);
+    // Armed, not removed: the dialog is still up and no DELETE went out.
+    expect(buttons[1].textContent).toBe('Confirm remove 2');
+    expect(buttons[1].classList.contains('jp-mod-armed')).toBe(true);
+    // The accessible name follows the visible label, which the Dialog's own
+    // label element would otherwise pin to Remove.
+    expect(labelOf(buttons[1]).getAttribute('aria-label')).toBe(
+      'Confirm remove 2'
+    );
+    expect(document.querySelector('.jp-Dialog')).not.toBeNull();
+    expect(deletes()).toHaveLength(0);
+
+    click(buttons[1]);
+    await done;
+    const sent = deletes();
+    expect(sent).toHaveLength(1);
+    expect(JSON.parse(sent[0][3].body).session_ids).toEqual([
+      'sid-branch-0',
+      'sid-branch-1'
+    ]);
+  });
+
+  it('ACC-PANE-234 - an armed Remove lapses after four seconds and the next activation arms again', async () => {
+    // The fetch fails: the newer state stays unknown, so arming stays required.
+    request.mockRejectedValueOnce(new Error('offline'));
+    const done = (panel as any)._cleanupParallel(
+      row(3, Date.now() - 2 * HOUR)
+    ) as Promise<void>;
+    const buttons = await openButtons();
+    expect(buttons[1].textContent).toBe('Remove (3)');
+
+    jest.useFakeTimers();
+    try {
+      click(buttons[1], 1, 1000);
+      expect(buttons[1].textContent).toBe('Confirm remove 3');
+
+      jest.advanceTimersByTime(4000);
+      expect(buttons[1].textContent).toBe('Remove (3)');
+      expect(buttons[1].classList.contains('jp-mod-armed')).toBe(false);
+
+      // The next activation starts the two steps again; it does not remove.
+      click(buttons[1], 1, 9000);
+      expect(buttons[1].textContent).toBe('Confirm remove 3');
+      expect(deletes()).toHaveLength(0);
+    } finally {
+      jest.useRealTimers();
+    }
+
+    buttons[0].click(); // Cancel
+    await done;
+    expect(deletes()).toHaveLength(0);
+  });
+
+  it('ACC-PANE-235 - the second click of a double-click does not confirm, and a later click does', async () => {
+    const now = Date.now();
+    serve([now - HOUR]);
+    const done = (panel as any)._cleanupParallel(
+      row(1, now - 2 * HOUR)
+    ) as Promise<void>;
+    const buttons = await openButtons();
+    expect(buttons[1].textContent).toBe('Remove (1)');
+
+    click(buttons[1], 1, 1000);
+    // 200 ms after the arming click, with detail 2: the double-click half is
+    // ignored and the arm stands.
+    click(buttons[1], 2, 1200);
+    await flush();
+    expect(buttons[1].textContent).toBe('Confirm remove 1');
+    expect(buttons[1].classList.contains('jp-mod-armed')).toBe(true);
+    expect(deletes()).toHaveLength(0);
+
+    // A later click confirms whatever its detail: 700 ms after arming.
+    click(buttons[1], 2, 1700);
+    await done;
+    expect(deletes()).toHaveLength(1);
+  });
+
+  it('ACC-PANE-236 - an unarmed activation never removes while the branch list is still being fetched', async () => {
+    const now = Date.now();
+    let release: ((value: any) => void) | undefined;
+    request.mockImplementationOnce(
+      () => new Promise(resolve => (release = resolve))
+    );
+    const done = (panel as any)._cleanupParallel(
+      row(2, now - 2 * HOUR)
+    ) as Promise<void>;
+    const buttons = await openButtons();
+
+    // The fetch is out: one activation arms and does not remove.
+    expect(buttons[1].textContent).toBe('Remove (2)');
+    click(buttons[1]);
+    expect(buttons[1].textContent).toBe('Confirm remove 2');
+    expect(deletes()).toHaveLength(0);
+
+    // The list lands with a conversation newer than the kept one; the earlier
+    // activation still must not have removed anything, and the arm is dropped
+    // so it cannot confirm this list either.
+    release!(branches([now - HOUR]));
+    await flush();
+    expect(
+      document.querySelector('.jp-AiAssistantsPanel-cleanupWarning')
+    ).not.toBeNull();
+    expect(buttons[1].textContent).toBe('Remove (1)');
+    expect(buttons[1].classList.contains('jp-mod-armed')).toBe(false);
+    expect(deletes()).toHaveLength(0);
+
+    buttons[0].click(); // Cancel
+    await done;
+    expect(deletes()).toHaveLength(0);
+  });
+
+  it('arms while the branch fetch is pending, before any newer state is known', async () => {
+    const now = Date.now();
+    let release: ((value: any) => void) | undefined;
+    request.mockImplementationOnce(
+      () => new Promise(resolve => (release = resolve))
+    );
+    const done = (panel as any)._cleanupParallel(
+      row(4, now - 2 * HOUR)
+    ) as Promise<void>;
+    const buttons = await openButtons();
+
+    // The row's own count while the list is unknown, and no warning yet.
+    expect(buttons[1].textContent).toBe('Remove (4)');
+    expect(
+      document.querySelector('.jp-AiAssistantsPanel-cleanupWarning')
+    ).toBeNull();
+    click(buttons[1]);
+    expect(buttons[1].textContent).toBe('Confirm remove 4');
+    expect(buttons[1].classList.contains('jp-mod-armed')).toBe(true);
+    expect(labelOf(buttons[1]).getAttribute('aria-label')).toBe(
+      'Confirm remove 4'
+    );
+    expect(deletes()).toHaveLength(0);
+
+    // Let the held fetch answer, then cancel, so the dialog leaves cleanly.
+    release!(branches([now - 3 * HOUR]));
+    await flush();
+    buttons[0].click();
+    await done;
+  });
+
+  it('arms after a failed branch fetch, and the second activation removes', async () => {
+    request.mockRejectedValueOnce(new Error('offline'));
+    // The removal's own refetch answers with the branch it deletes.
+    request.mockResolvedValueOnce({
+      current: 'sid-kept',
+      total: 2,
+      branches: [
+        { session_id: 'sid-branch-0', file_mtime: 1, label: 'Branch 0' }
+      ]
+    });
+    const done = (panel as any)._cleanupParallel(
+      row(3, Date.now() - 2 * HOUR)
+    ) as Promise<void>;
+    const buttons = await openButtons();
+
+    expect(buttons[1].textContent).toBe('Remove (3)');
+    click(buttons[1]);
+    expect(buttons[1].textContent).toBe('Confirm remove 3');
+    expect(deletes()).toHaveLength(0);
+
+    click(buttons[1]);
+    await done;
+    const sent = deletes();
+    expect(sent).toHaveLength(1);
+    expect(JSON.parse(sent[0][3].body).session_ids).toEqual(['sid-branch-0']);
+  });
+
+  it('a restatement drops an arm given before the list landed and relabels with the new count', async () => {
+    const now = Date.now();
+    let release: ((value: any) => void) | undefined;
+    request.mockImplementationOnce(
+      () => new Promise(resolve => (release = resolve))
+    );
+    const done = (panel as any)._cleanupParallel(
+      row(3, now - 2 * HOUR)
+    ) as Promise<void>;
+    const buttons = await openButtons();
+
+    click(buttons[1]);
+    expect(buttons[1].textContent).toBe('Confirm remove 3');
+    expect(buttons[1].classList.contains('jp-mod-armed')).toBe(true);
+
+    // The fetched list holds two conversations, one newer: the count changes
+    // and the warning appears, so the arm must not survive to confirm them.
+    release!(branches([now - HOUR, now - 3 * HOUR]));
+    await flush();
+    expect(buttons[1].textContent).toBe('Remove (2)');
+    expect(buttons[1].classList.contains('jp-mod-armed')).toBe(false);
+    expect(deletes()).toHaveLength(0);
+
+    // The two steps now apply to the restated list.
+    click(buttons[1]);
+    expect(buttons[1].textContent).toBe('Confirm remove 2');
+    click(buttons[1]);
+    await done;
+    expect(JSON.parse(deletes()[0][3].body).session_ids).toEqual([
+      'sid-branch-0',
+      'sid-branch-1'
+    ]);
+  });
+
+  it('keeps the one-click Remove when the fetched list has no newer conversation', async () => {
+    const now = Date.now();
+    serve([now - 3 * HOUR]);
+    const done = (panel as any)._cleanupParallel(
+      row(1, now - 2 * HOUR)
+    ) as Promise<void>;
+    const buttons = await openButtons();
+
+    expect(
+      document.querySelector('.jp-AiAssistantsPanel-cleanupWarning')
+    ).toBeNull();
+    expect(buttons[1].textContent).toBe('Remove');
+    expect(buttons[1].classList.contains('jp-mod-armed')).toBe(false);
+
+    click(buttons[1]);
+    await done;
+    expect(deletes()).toHaveLength(1);
+  });
+
+  it('Enter and Space on the accept button arm first and confirm second', async () => {
+    const now = Date.now();
+    serve([now - HOUR]);
+
+    let done = (panel as any)._cleanupParallel(
+      row(1, now - 2 * HOUR)
+    ) as Promise<void>;
+    let buttons = await openButtons();
+    buttons[1].focus();
+    // The capture handler must consume the Enter default: a real browser
+    // would otherwise fire the focused button's activation click, and that
+    // click would confirm in one press.
+    const armingEnter = pressEnter();
+    expect(armingEnter.defaultPrevented).toBe(true);
+    expect(buttons[1].textContent).toBe('Confirm remove 1');
+    expect(deletes()).toHaveLength(0);
+    // A held Enter sends repeats; they are not a second press and must not
+    // confirm, though the Dialog's own Enter handler would resolve the accept.
+    const repeatEnter = pressEnter(true);
+    expect(repeatEnter.defaultPrevented).toBe(true);
+    expect(deletes()).toHaveLength(0);
+    expect(document.querySelector('.jp-Dialog')).not.toBeNull();
+    expect(buttons[1].textContent).toBe('Confirm remove 1');
+    expect(buttons[1].classList.contains('jp-mod-armed')).toBe(true);
+    pressEnter();
+    await done;
+    expect(deletes()).toHaveLength(1);
+    await closeProgress();
+
+    // Space reaches a button as a click; the same two steps hold.
+    request.mockClear();
+    done = (panel as any)._cleanupParallel(
+      row(1, now - 2 * HOUR)
+    ) as Promise<void>;
+    buttons = await openButtons();
+    buttons[1].click();
+    expect(buttons[1].textContent).toBe('Confirm remove 1');
+    expect(deletes()).toHaveLength(0);
+    buttons[1].click();
+    await done;
+    expect(deletes()).toHaveLength(1);
+  });
+});
+
 describe('ACC-PANE-35..45 - what a row and a section show', () => {
   const MINUTE = 60_000;
   const HOUR = 3_600_000;

package/src/__tests__/popup.spec.ts

@@ -232,8 +232,8 @@ describe('Manage Sessions popup Delete button (DEF-PANE-307)', () => {
   });
 
   it('names the trash outcome without promising recoverability', () => {
-    expect(deleteButton().title).toContain(
-      'a refused move may remove them permanently or leave them in place'
+    expect(deleteButton().title).toBe(
+      'Deleted conversations go to the trash; a refused move deletes permanently.'
     );
   });
 

package/src/core/panel.ts

@@ -3,8 +3,7 @@ import {
   Clipboard,
   Dialog,
   InputDialog,
-  Notification,
-  showDialog
+  Notification
 } from '@jupyterlab/apputils';
 import { IDefaultFileBrowser } from '@jupyterlab/filebrowser';
 import { ServerConnection } from '@jupyterlab/services';
@@ -789,29 +788,32 @@ export class AssistantSessionsPanel extends Widget {
     }
   }
 
-  /** The warning a deletion earns: with the trash setting on, a refused move
-   * may remove the conversations permanently or leave them in place, so
-   * neither the verb nor the note may promise one outcome. */
-  private get _irreversibleNote(): string {
-    return this._deleteToTrash
-      ? ' A permanent removal cannot be undone.'
-      : ' This cannot be undone.';
-  }
-
-  private get _disposalVerb(): string {
-    return this._deleteToTrash
-      ? 'moved to the trash when the system accepts them; a refused move may remove them permanently or leave them in place'
-      : 'deleted permanently';
-  }
-
   private async _removeProject(session: ISession): Promise<void> {
     const name = this._lookupName(session);
-    const confirm = await showDialog({
-      title: `Remove from ${this._descriptor.label}`,
-      body:
-        `Remove "${name}" from ${this._descriptor.label}? This drops the ` +
-        `entire project history and every conversation it holds - ` +
-        `${this._disposalVerb}.${this._irreversibleNote}`,
+    const title = `Remove from ${this._descriptor.label}`;
+    // The consequence only, in two lines: the question and the outcome, then
+    // the permanent-deletion refusal on its own caution line
+    // (DEF-PANE-371-DIALOG-TEXT).
+    const outcome = this._deleteToTrash
+      ? `Remove "${name}"? Every conversation in it goes to the trash.`
+      : `Remove "${name}"? Every conversation in it is deleted permanently.`;
+    const caution = this._deleteToTrash
+      ? 'A refused move deletes permanently.'
+      : '';
+    const body = new Widget();
+    body.node.className = 'jp-AiAssistantsPanel-removeConfirm';
+    const question = document.createElement('p');
+    question.textContent = outcome;
+    body.node.appendChild(question);
+    if (caution) {
+      const line = document.createElement('p');
+      line.className = 'jp-AiAssistantsPanel-removeCaution';
+      line.textContent = caution;
+      body.node.appendChild(line);
+    }
+    const dialog = new Dialog<unknown>({
+      title,
+      body,
       buttons: [
         Dialog.cancelButton(),
         Dialog.warnButton({ label: this._trans.__('Remove') })
@@ -824,6 +826,12 @@ export class AssistantSessionsPanel extends Widget {
       defaultButton: 0,
       renderer: dialogRenderer
     });
+    // A Widget body leaves the Dialog no string to name itself from.
+    dialog.node.setAttribute(
+      'aria-label',
+      [title, outcome, caution].filter(part => part).join(' ')
+    );
+    const confirm = await dialog.launch();
     if (!confirm.button.accept) {
       return;
     }
@@ -873,23 +881,25 @@ export class AssistantSessionsPanel extends Widget {
     };
     askCount(extra);
     confirmBody.node.appendChild(question);
-    // One sentence, twelve words or fewer: what happens, not the detail.
+    // The second line states what happens to the rest: the count, the short
+    // ids once the branch list names them, and the disposal the setting chose.
     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.';
+    // Announced when restated with the short ids; an aria-label change is not.
+    hint.setAttribute('role', 'status');
+    const stateHint = (ids: string[] | null): void => {
+      const shortIds = ids?.map(id =>
+        shortSessionId(id, this._descriptor.sessionIdPrefix)
+      );
+      hint.textContent =
+        `Remaining ${extra} session${extra === 1 ? '' : 's'}` +
+        (shortIds?.length ? ` ${shortIds.join(', ')}` : '') +
+        (this._deleteToTrash
+          ? ' will be removed.'
+          : ' will be deleted permanently.');
+    };
+    stateHint(null);
     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;
@@ -904,9 +914,11 @@ 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.
+    // Scopes the armed style in base.css to this one dialog.
+    confirmDialog.addClass('jp-AiAssistantsPanel-cleanupDialog');
+    // The Dialog names itself only when its body is a string, and this body is
+    // a Widget: name it here, and again when the question and hint are
+    // restated and the warning joins it.
     const nameDialog = (): void => {
       confirmDialog.node.setAttribute(
         'aria-label',
@@ -914,7 +926,6 @@ export class AssistantSessionsPanel extends Widget {
           title,
           question.textContent ?? '',
           hint.textContent ?? '',
-          caution.textContent ?? '',
           warning?.textContent ?? ''
         ]
           .filter(part => part)
@@ -923,13 +934,126 @@ export class AssistantSessionsPanel extends Widget {
     };
     nameDialog();
 
+    // The house two-step destructive action (design-language.md, "Two-step
+    // destructive action"; the branch popup's Delete is the shipped form):
+    // while the newer state is unknown or newer, the accept button arms on the
+    // first activation and removes on the second, the arm lapsing after 4 s.
+    // It starts required: the branch fetch that decides whether a removal is
+    // safe is still out when the dialog opens.
+    let armRequired = true;
+    let armed = false;
+    let armTimer = 0;
+    // The arming activation's event.timeStamp, which the confirming one is
+    // measured against.
+    let armedAt = 0;
+
+    /** Find and relabel the accept button. The Dialog keeps its button nodes
+     * private and puts the label in a child whose aria-label overrides its
+     * text, so both are set. */
+    const updateAccept = (): void => {
+      const button =
+        confirmDialog.node.querySelector<HTMLButtonElement>('.jp-mod-accept');
+      const label = button?.querySelector('.jp-Dialog-buttonLabel');
+      if (!button || !label) {
+        return;
+      }
+      const text = armed
+        ? this._trans.__('Confirm remove %1', extra)
+        : armRequired
+          ? this._trans.__('Remove (%1)', extra)
+          : this._trans.__('Remove');
+      label.textContent = text;
+      label.setAttribute('aria-label', text);
+      button.classList.toggle('jp-mod-armed', armed);
+    };
+
+    const disarm = (): void => {
+      armed = false;
+      window.clearTimeout(armTimer);
+    };
+
+    /** Consume one accept activation. True means it only armed, or was the
+     * ignored half of a double-click, and the Dialog must not resolve; false
+     * lets the Dialog's own handler resolve it. */
+    const activate = (event: MouseEvent | KeyboardEvent): boolean => {
+      if (!armRequired) {
+        return false;
+      }
+      // The second click of a double-click is not a confirmation (DEF-PANE-336):
+      // a multi-click within 600 ms of arming is ignored. A later click
+      // confirms whatever its detail, since the OS double-click interval can
+      // be longer than the user's pause (DEF-PANE-338).
+      if (armed && event.detail > 1 && event.timeStamp - armedAt < 600) {
+        return true;
+      }
+      if (!armed) {
+        armed = true;
+        armedAt = event.timeStamp;
+        window.clearTimeout(armTimer);
+        armTimer = window.setTimeout(() => {
+          disarm();
+          updateAccept();
+        }, 4000);
+        updateAccept();
+        return true;
+      }
+      disarm();
+      return false;
+    };
+
+    // Registered before launch(): the Dialog attaches its own capture
+    // listeners on this same node when launch() attaches it, so these run
+    // first and can swallow an activation that must only arm. Space arrives
+    // as a click; Enter arrives as a keydown the Dialog would otherwise
+    // resolve from, so both are intercepted here.
+    confirmDialog.node.addEventListener(
+      'click',
+      event => {
+        const button = confirmDialog.node.querySelector('.jp-mod-accept');
+        if (!button || !button.contains(event.target as Node)) {
+          return;
+        }
+        if (activate(event)) {
+          event.stopImmediatePropagation();
+          event.preventDefault();
+        }
+      },
+      true
+    );
+    confirmDialog.node.addEventListener(
+      'keydown',
+      event => {
+        if (event.key !== 'Enter') {
+          return;
+        }
+        const accept = confirmDialog.node.querySelector('.jp-mod-accept');
+        if (!accept || document.activeElement !== accept) {
+          return;
+        }
+        // A held key's auto-repeat is not a second press (DEF-PANE-347): it
+        // must neither confirm nor arm, and consuming it stops the Dialog's
+        // own Enter handler from resolving the accept.
+        if (event.repeat) {
+          event.stopImmediatePropagation();
+          event.preventDefault();
+          return;
+        }
+        if (activate(event)) {
+          event.stopImmediatePropagation();
+          event.preventDefault();
+        }
+      },
+      true
+    );
+    updateAccept();
+
     // 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.
+    // question and hint state its length and ids, and a conversation newer
+    // than the kept one adds the warning, drawn last so it reads after the
+    // hint. The same list is what the removal deletes. A failed fetch leaves
+    // the question as the row reported it, with no ids and no warning, and
+    // the removal fetches again below.
     const branchesReady = this._fetchBranches(session).then(
       fetched => {
         const list = fetched?.branches;
@@ -944,6 +1068,7 @@ export class AssistantSessionsPanel extends Widget {
         } else if (list) {
           extra = list.length;
           askCount(extra);
+          stateHint(list.map(branch => branch.session_id));
           const newer = list.filter(
             branch => branch.file_mtime > session.file_mtime
           ).length;
@@ -953,9 +1078,16 @@ export class AssistantSessionsPanel extends Widget {
             warning.setAttribute('role', 'alert');
             warning.textContent =
               `${newer} parallel session${newer === 1 ? ' was' : 's were'} ` +
-              'active after the one kept.';
+              'active after the current session.';
             confirmBody.node.appendChild(warning);
           }
+          // The list just decided what the button acts on: an arm given while
+          // it was pending could confirm a different set, so drop it and
+          // restate the label with the fetched count. With no newer branch the
+          // button returns to the one-click Remove.
+          disarm();
+          armRequired = newer > 0;
+          updateAccept();
           nameDialog();
         }
         return fetched;

package/src/core/popup.ts

@@ -162,7 +162,7 @@ export function showManageSessionsPopup(
   deleteBtn.type = 'button';
   deleteBtn.className = 'jp-AiAssistantsPanel-branchDelete';
   deleteBtn.title = options.deleteToTrash
-    ? 'Deleted conversations move to the trash when the system accepts them; a refused move may remove them permanently or leave them in place'
+    ? 'Deleted conversations go to the trash; a refused move deletes permanently.'
     : 'Deleted conversations are removed permanently';
   footer.appendChild(deleteBtn);
   // Plain visual counter (selection, or the last action), beside the button

package/style/base.css

@@ -683,20 +683,23 @@ 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
+/* The two destructive confirmations' lines: the Remove question with its
+   caution, and the cleanup question, hint 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 {
+.jp-AiAssistantsPanel-cleanupConfirm,
+.jp-AiAssistantsPanel-removeConfirm {
   display: flex;
   flex-direction: column;
   gap: 8px;
   max-width: 440px;
 }
 
-.jp-AiAssistantsPanel-cleanupConfirm p {
+.jp-AiAssistantsPanel-cleanupConfirm p,
+.jp-AiAssistantsPanel-removeConfirm p {
   margin: 0;
 }
 
@@ -712,6 +715,16 @@ body[data-jp-theme-light='true'] .jp-AiAssistantsPanel-dotHalo {
   color: var(--jp-ui-font-color1);
 }
 
+/* Armed for the second step of the destructive action (design-language.md,
+   "Two-step destructive action"): the error fill, as the branch popup's
+   Delete carries it. Scoped to the Clean Up confirmation's own dialog, so no
+   other dialog changes. */
+.jp-AiAssistantsPanel-cleanupDialog .jp-Dialog-button.jp-mod-armed,
+.jp-AiAssistantsPanel-cleanupDialog .jp-Dialog-button.jp-mod-armed:hover {
+  background: var(--jp-error-color1);
+  color: var(--jp-ui-inverse-font-color1);
+}
+
 .jp-AiAssistantsPanel-row.jp-mod-busy {
   opacity: 0.55;
   pointer-events: none;