jupyterlab_ai_code_assistants_extension 1.2.288 → 1.2.294

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;
         }
@@ -792,7 +801,7 @@ export class AssistantSessionsPanel extends Widget {
         caution.className = 'jp-AiAssistantsPanel-cleanupCaution';
         caution.textContent = this._deleteToTrash
             ? 'A refused trash move deletes permanently and cannot be undone.'
-            : this._irreversibleNote.trim();
+            : 'This cannot be undone.';
         confirmBody.node.appendChild(caution);
         const title = this._trans.__('Clean Up Parallel Sessions');
         let warning = null;
@@ -807,9 +816,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 is restated and the
+        // warning joins it.
         const nameDialog = () => {
             var _a, _b, _c, _d;
             confirmDialog.node.setAttribute('aria-label', [
@@ -823,6 +834,105 @@ export class AssistantSessionsPanel extends Widget {
                 .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
@@ -854,6 +964,13 @@ export class AssistantSessionsPanel extends Widget {
                             'active after the one kept.';
                     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.294",
     "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'
-    );
-    expect(body).toContain('A permanent removal cannot be undone');
+    // 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(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,9 +2309,9 @@ 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();
@@ -2583,6 +2606,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;
     }
@@ -888,7 +896,7 @@ export class AssistantSessionsPanel extends Widget {
     caution.className = 'jp-AiAssistantsPanel-cleanupCaution';
     caution.textContent = this._deleteToTrash
       ? 'A refused trash move deletes permanently and cannot be undone.'
-      : this._irreversibleNote.trim();
+      : 'This cannot be undone.';
     confirmBody.node.appendChild(caution);
 
     const title = this._trans.__('Clean Up Parallel Sessions');
@@ -904,9 +912,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 is restated and the
+    // warning joins it.
     const nameDialog = (): void => {
       confirmDialog.node.setAttribute(
         'aria-label',
@@ -923,6 +933,119 @@ 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
@@ -956,6 +1079,13 @@ export class AssistantSessionsPanel extends Widget {
               'active after the one kept.';
             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, 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 {
+.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;