jupyterlab_ai_code_assistants_extension 1.2.236 → 1.2.271

package/lib/core/panel.d.ts

@@ -382,6 +382,10 @@ export declare class AssistantSessionsPanel extends Widget {
      * `_fetch`. */
     private _fetchSent;
     private _fetchDrawn;
+    /** The `_fetchSent` number at each removal's DELETE, by encoded path. A
+     * listing sent before that number may still carry the removed project, so
+     * `_fetch` drops it (DEF-PANE-351-WRITE-ORDER). */
+    private readonly _removedAt;
     /** A button is pressed in the list, and a redraw waits for its release -
      * see `_onRelease`. */
     private _pressed;

package/lib/core/panel.js

@@ -1,5 +1,5 @@
 import { Clipboard, Dialog, InputDialog, Notification, showDialog } from '@jupyterlab/apputils';
-import { MenuSvg, closeIcon, editIcon, folderIcon, terminalIcon } from '@jupyterlab/ui-components';
+import { MenuSvg, closeIcon, copyIcon, editIcon, folderIcon, terminalIcon } from '@jupyterlab/ui-components';
 import { nullTranslator } from '@jupyterlab/translation';
 import { CommandRegistry } from '@lumino/commands';
 import { UUID } from '@lumino/coreutils';
@@ -76,8 +76,9 @@ let fileBrowserMoves = Promise.resolve();
  * later click does not move the file browser, so it ends on the folder of the
  * newest click that opened (DEF-PANE-343). The same counter orders the writes
  * that decide a project's current conversation: a row click, an explicit
- * switch and a fork each take a number, and a row click posts its deferred
- * switch only while it is the newest (DEF-PANE-349). */
+ * switch, a fork and a New Session (+) each take a number, and a row click
+ * posts its deferred switch only while it is the newest (DEF-PANE-349,
+ * DEF-PANE-355). */
 let openClicks = 0;
 let movedClick = 0;
 function loadExpanded(storageKey) {
@@ -179,6 +180,10 @@ export class AssistantSessionsPanel extends Widget {
          * `_fetch`. */
         this._fetchSent = 0;
         this._fetchDrawn = 0;
+        /** The `_fetchSent` number at each removal's DELETE, by encoded path. A
+         * listing sent before that number may still carry the removed project, so
+         * `_fetch` drops it (DEF-PANE-351-WRITE-ORDER). */
+        this._removedAt = new Map();
         /** A button is pressed in the list, and a redraw waits for its release -
          * see `_onRelease`. */
         this._pressed = false;
@@ -640,7 +645,9 @@ export class AssistantSessionsPanel extends Widget {
             return;
         }
         this._fetchDrawn = request;
-        this._sessions = (_a = data.sessions) !== null && _a !== void 0 ? _a : [];
+        // A project removed at or after this listing was sent must not be drawn
+        // back from the answer (DEF-PANE-351-WRITE-ORDER).
+        this._sessions = ((_a = data.sessions) !== null && _a !== void 0 ? _a : []).filter(s => { var _a; return ((_a = this._removedAt.get(s.encoded_path)) !== null && _a !== void 0 ? _a : 0) < request; });
         this._setInlineError(null);
         this._terminals.setSessions(this._sessions);
         this._render();
@@ -659,6 +666,10 @@ export class AssistantSessionsPanel extends Widget {
                     favourite: next
                 })
             });
+            // A listing sent before the write may still be drawn, and a poll may
+            // have replaced the row this wrote; this one is answered after the write
+            // (DEF-PANE-351).
+            void this._fetch().catch(() => undefined);
         }
         catch (err) {
             session.favourite = !next; // roll back
@@ -711,6 +722,11 @@ export class AssistantSessionsPanel extends Widget {
             });
             // Drop locally; the next poll reconciles against disk.
             this._sessions = ((_a = this._sessions) !== null && _a !== void 0 ? _a : []).filter(s => s.encoded_path !== session.encoded_path);
+            // A listing sent before the delete may still be drawn (DEF-PANE-351),
+            // and it carries the removed project: the number taken here marks the
+            // answer for `_fetch` to drop (DEF-PANE-351-WRITE-ORDER).
+            this._removedAt.set(session.encoded_path, this._fetchSent);
+            void this._fetch().catch(() => undefined);
         }
         catch (err) {
             this._showActionError(`Could not remove "${name}" - try again.`, err);
@@ -999,7 +1015,7 @@ export class AssistantSessionsPanel extends Widget {
                 // The terminal a launch before this click opened for it counts too,
                 // before the server can read the conversation off its process
                 // (DEF-PANE-345).
-                const found = (_c = this._terminals.cached(folder, row.session_id)) !== null && _c !== void 0 ? _c : (_d = (await this._terminals.findForSession(row.session_id, folder))) === null || _d === void 0 ? void 0 : _d.widget;
+                const found = (_c = (await this._terminals.cached(folder, row.session_id))) !== null && _c !== void 0 ? _c : (_d = (await this._terminals.findForSession(row.session_id, folder))) === null || _d === void 0 ? void 0 : _d.widget;
                 if (found) {
                     this._terminals.focus(found);
                     return found;
@@ -1071,6 +1087,15 @@ export class AssistantSessionsPanel extends Widget {
         // store key lets the server clear that pin so the new conversation is not
         // shadowed by a stale one (DEF-9).
         const existing = ((_a = this._sessions) !== null && _a !== void 0 ? _a : []).find(s => s.project_path === projectPath);
+        if (existing) {
+            // The + click is the project's newest decision: a row open still
+            // finishing posts no switch over it (DEF-PANE-355). It has no id to post;
+            // the launch route clears the pin.
+            this._currentTokens.set(existing.encoded_path, {
+                click: ++openClicks,
+                sessionId: ''
+            });
+        }
         // Raised on the click, not by the launch: the launch waits for a tile
         // launch clicked before it (DEF-PANE-345).
         const busy = beginSpinner(this._trans.__('Opening %1', this._descriptor.label), this._trans);
@@ -1328,7 +1353,8 @@ export class AssistantSessionsPanel extends Widget {
         const key = session.encoded_path;
         const run = ((_a = this._switchChains.get(key)) !== null && _a !== void 0 ? _a : Promise.resolve()).then(async () => {
             const newest = this._currentTokens.get(key);
-            if (!newest) {
+            // An empty id is a New Session (+) decision, which posts nothing.
+            if (!(newest === null || newest === void 0 ? void 0 : newest.sessionId)) {
                 return;
             }
             if (!force && this._postedClicks.get(key) === newest.click) {
@@ -2097,6 +2123,7 @@ export class AssistantSessionsPanel extends Widget {
         });
         this._commands.addCommand(this._cmd('copy-path'), {
             label: this._trans.__('Copy Path'),
+            icon: copyIcon,
             execute: () => {
                 const s = active();
                 if (s) {
@@ -2106,6 +2133,7 @@ export class AssistantSessionsPanel extends Widget {
         });
         this._commands.addCommand(this._cmd('copy-session-id'), {
             label: this._trans.__('Copy Session ID'),
+            icon: copyIcon,
             execute: () => {
                 var _a;
                 const id = (_a = active()) === null || _a === void 0 ? void 0 : _a.session_id;
@@ -2145,6 +2173,9 @@ export class AssistantSessionsPanel extends Widget {
             // item beside an ordinary one (DEF-45). The sweep variant of the trash
             // glyph, because this one deletes several at once.
             icon: cleanupIcon,
+            // Both history-deleting entries draw their icon in the error colour
+            // (base.css).
+            className: 'jp-AiAssistantsContextMenu-danger',
             isVisible: () => { var _a, _b; return ((_b = (_a = active()) === null || _a === void 0 ? void 0 : _a.extra_sessions) !== null && _b !== void 0 ? _b : 0) > 0; },
             execute: () => {
                 const s = active();
@@ -2241,6 +2272,7 @@ export class AssistantSessionsPanel extends Widget {
         this._commands.addCommand(this._cmd('remove'), {
             label: `Remove from ${this._descriptor.label}`,
             icon: removeIcon,
+            className: 'jp-AiAssistantsContextMenu-danger',
             execute: () => {
                 const s = active();
                 if (s) {

package/lib/core/terminals.d.ts

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

package/lib/core/terminals.js

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

package/lib/index.js

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

package/package.json

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

package/src/__tests__/index.spec.ts

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

package/src/__tests__/panel.spec.ts

@@ -51,7 +51,12 @@ jest.mock('../core/request', () => ({
 }));
 
 import { Clipboard, Dialog, Notification } from '@jupyterlab/apputils';
+import { copyIcon } from '@jupyterlab/ui-components';
 import { CommandRegistry } from '@lumino/commands';
+
+import { readFileSync } from 'fs';
+import { join } from 'path';
+
 import { addIcon, branchIcon, cleanupIcon, shieldIcon } from '../core/icons';
 import {
   AssistantSessionsPanel,
@@ -238,8 +243,10 @@ describe('DEF-51 - the destructive dialogs open with Cancel under the keyboard',
     pressEnter();
     await done;
 
-    expect(request).toHaveBeenCalledTimes(1);
+    // The DELETE, then the listing refetched after it (DEF-PANE-351).
+    expect(request).toHaveBeenCalledTimes(2);
     expect(request.mock.calls[0][3]).toMatchObject({ method: 'DELETE' });
+    expect(request.mock.calls[1][1]).toBe('sessions');
   });
 
   it('Clean Up Parallel Sessions: Enter on the fresh dialog cancels', async () => {
@@ -425,6 +432,67 @@ describe('DEF-45 - both destructive menu entries are marked alike', () => {
   });
 });
 
+describe('ACC-PANE-218 - the history-deleting entries carry the danger class', () => {
+  it('paints the label and the icon with the error colour and leaves the background alone', () => {
+    // jsdom applies no stylesheet, so the rule that makes the class visible is
+    // read as text. The label inherits the item's color; JupyterLab's selected
+    // rule sets only the background, so nothing here may set one, nor the
+    // inverse text colour the superseded filled row used.
+    const css = readFileSync(
+      join(__dirname, '..', '..', 'style', 'base.css'),
+      'utf8'
+    );
+    expect(css).toMatch(
+      /\.jp-AiAssistantsContextMenu-danger\s*\{[^}]*color:\s*var\(--jp-error-color1\)/
+    );
+    expect(css).toMatch(
+      /\.jp-AiAssistantsContextMenu-danger \.jp-icon3\[fill\]\s*\{[^}]*fill:\s*var\(--jp-error-color1\)/
+    );
+    const rules = [
+      ...css.matchAll(
+        /([^{}]*\.jp-AiAssistantsContextMenu-danger[^{}]*)\{([^}]*)\}/g
+      )
+    ];
+    expect(rules.length).toBeGreaterThanOrEqual(2);
+    for (const [, selector, body] of rules) {
+      expect(selector).not.toContain('.lm-mod-active');
+      expect(body).not.toMatch(/\bbackground\b/);
+      expect(body).not.toContain('--jp-ui-inverse-font-color1');
+    }
+  });
+
+  it('puts the class on cleanup-parallel and remove, and on no other entry', () => {
+    // base.css draws the icon of this class in --jp-error-color1; the menu
+    // item takes the class from the command options.
+    const commands = (panel as any)._commands as CommandRegistry;
+    const marked = commands
+      .listCommands()
+      .filter(id => commands.className(id, {}) !== '');
+    expect(marked.sort()).toEqual(
+      [
+        commandId(DESCRIPTOR.id, 'cleanup-parallel'),
+        commandId(DESCRIPTOR.id, 'remove')
+      ].sort()
+    );
+    for (const id of marked) {
+      expect(commands.className(id, {})).toBe(
+        'jp-AiAssistantsContextMenu-danger'
+      );
+    }
+  });
+});
+
+describe('ACC-PANE-219 - the copy entries carry the copy icon', () => {
+  it('gives Copy Path and Copy Session ID copyIcon', () => {
+    const commands = (panel as any)._commands as CommandRegistry;
+    for (const action of ['copy-path', 'copy-session-id']) {
+      expect(commands.icon(commandId(DESCRIPTOR.id, action), {})).toBe(
+        copyIcon
+      );
+    }
+  });
+});
+
 describe('ACC-SESS-203 - automatic branch names', () => {
   it.each(['server-copy', 'server-native'] as const)(
     '%s requests a numbered name and resumes the returned child without a dialog',
@@ -1231,6 +1299,113 @@ describe('DEF-PANE-349 - a row click makes the clicked session the project curre
     }
   });
 
+  it('drops a pending row switch after New Session (+) in the same project', async () => {
+    // + starts a new conversation and the launch route clears the pin. A row
+    // click still opening must not pin the old conversation over it
+    // (DEF-PANE-355).
+    const row = session({ name: 'proj' });
+    let releaseOpen!: () => void;
+    const pending = new Promise<void>(resolve => {
+      releaseOpen = resolve;
+    });
+    (panel as any)._terminals.openSession = jest.fn(() => pending);
+    const launch = jest.fn().mockResolvedValue({ id: 'term-new' });
+    (panel as any)._terminals.launch = launch;
+    (panel as any)._currentFolder = () => row.project_path;
+    (panel as any)._fetch = jest.fn().mockResolvedValue(undefined);
+    request.mockImplementation((_id: string, route: string) =>
+      Promise.resolve(
+        route === 'switch'
+          ? { requested: row.session_id, current: row.session_id }
+          : { sessions: [] }
+      )
+    );
+    try {
+      render(panel, [row]);
+      panel.node
+        .querySelector<HTMLElement>('.jp-AiAssistantsPanel-row')!
+        .click();
+      await flush();
+
+      await (panel as any)._newSession();
+      expect(launch).toHaveBeenCalledTimes(1);
+      expect(launch.mock.calls[0][0]).toMatchObject({
+        encoded_path: row.encoded_path
+      });
+
+      releaseOpen();
+      await flush();
+
+      expect(request.mock.calls.map(call => call[1])).not.toContain('switch');
+    } finally {
+      releaseOpen();
+      await flush();
+    }
+  });
+
+  it('posts no queued row switch once New Session (+) is the newest decision', async () => {
+    // A row switch queued behind a post in flight reads the newest decision
+    // when it runs; a + made meanwhile has no id to post (DEF-PANE-355).
+    const first = session({
+      name: 'first',
+      project_path: '/home/user/shared',
+      encoded_path: 'enc-shared'
+    });
+    const second = session({
+      name: 'second',
+      project_path: '/home/user/shared',
+      encoded_path: 'enc-shared',
+      session_id: 'sid-second'
+    });
+    let releasePost!: () => void;
+    const heldPost = new Promise<void>(resolve => {
+      releasePost = resolve;
+    });
+    (panel as any)._terminals.openSession = jest.fn(() => Promise.resolve());
+    (panel as any)._terminals.launch = jest
+      .fn()
+      .mockResolvedValue({ id: 'term-new' });
+    (panel as any)._currentFolder = () => first.project_path;
+    (panel as any)._fetch = jest.fn().mockResolvedValue(undefined);
+    request.mockImplementation(
+      async (_id: string, route: string, _settings: unknown, init: any) => {
+        if (route !== 'switch') {
+          return { sessions: [] };
+        }
+        const body = JSON.parse(init.body);
+        if (body.session_id === first.session_id) {
+          await heldPost;
+        }
+        return { requested: body.session_id, current: body.session_id };
+      }
+    );
+    try {
+      render(panel, [first, second]);
+      const rows = panel.node.querySelectorAll<HTMLElement>(
+        '.jp-AiAssistantsPanel-row'
+      );
+      rows[0].click();
+      await flush();
+      rows[1].click();
+      await flush();
+
+      await (panel as any)._newSession();
+      releasePost();
+      await flush();
+
+      const switches = request.mock.calls.filter(
+        ([, route]) => route === 'switch'
+      );
+      expect(switches).toHaveLength(1);
+      expect(JSON.parse((switches[0][3] as any).body).session_id).toBe(
+        first.session_id
+      );
+    } finally {
+      releasePost();
+      await flush();
+    }
+  });
+
   it('posts the row switch when a held Branch answers before a later row open', async () => {
     // The fork's number is the Branch click's, so a row clicked after it wins
     // even when the fork route answers first (DEF-PANE-349).
@@ -2786,6 +2961,118 @@ describe('DEF-PANE-344 - the session list', () => {
     ]);
   });
 
+  /** Hold every listing request, in the order sent; other routes answer
+   * `answer`. */
+  const holdListings = (answer: unknown): Array<(v: unknown) => void> => {
+    const held: Array<(v: unknown) => void> = [];
+    request.mockImplementation((_id: string, path: string, _s, init?: any) =>
+      path === 'sessions' && !init?.method
+        ? new Promise(resolve => held.push(resolve))
+        : Promise.resolve(answer)
+    );
+    return held;
+  };
+
+  it('DEF-PANE-351 - a listing sent before Remove gives way to the one after it', async () => {
+    const alpha = session({ name: 'alpha' });
+    const beta = session({ name: 'beta' });
+    render(panel, [alpha, beta]);
+    const held = holdListings({});
+    const poll = (panel as any)._fetch();
+    const removing = (panel as any)._removeProject(alpha);
+    await flush();
+    Array.from(
+      document.querySelectorAll<HTMLButtonElement>('.jp-Dialog-button')
+    )
+      .find(b => b.textContent === 'Remove')!
+      .click();
+    await removing;
+    // The listing sent before the delete answers first, then every one sent
+    // after it answers with what the server holds now.
+    held[0]({ sessions: [alpha, beta] });
+    await poll;
+    held.slice(1).forEach(answer => answer({ sessions: [beta] }));
+    await flush();
+    expect((panel as any)._sessions.map((s: ISession) => s.name)).toEqual([
+      'beta'
+    ]);
+  });
+
+  it('DEF-PANE-351-WRITE-ORDER - a listing sent before Remove never draws the removed project again', async () => {
+    const alpha = session({ name: 'alpha' });
+    const beta = session({ name: 'beta' });
+    render(panel, [alpha, beta]);
+    const held = holdListings({});
+    const poll = (panel as any)._fetch();
+    const removing = (panel as any)._removeProject(alpha);
+    await flush();
+    Array.from(
+      document.querySelectorAll<HTMLButtonElement>('.jp-Dialog-button')
+    )
+      .find(b => b.textContent === 'Remove')!
+      .click();
+    await removing;
+    // The listing sent before the delete answers with the project still in
+    // it, and the refetch after the delete is still held.
+    held[0]({ sessions: [alpha, beta] });
+    await poll;
+    expect((panel as any)._sessions.map((s: ISession) => s.name)).toEqual([
+      'beta'
+    ]);
+    held.slice(1).forEach(answer => answer({ sessions: [beta] }));
+    await flush();
+  });
+
+  it('DEF-PANE-351 - a listing sent before a favourite toggle gives way to the one after it', async () => {
+    const alpha = session({ name: 'alpha' });
+    render(panel, [alpha]);
+    const held = holdListings({ favourite: true });
+    const poll = (panel as any)._fetch();
+    await (panel as any)._toggleFavourite(alpha);
+    held[0]({ sessions: [session({ name: 'alpha', favourite: false })] });
+    await poll;
+    held
+      .slice(1)
+      .forEach(answer =>
+        answer({ sessions: [session({ name: 'alpha', favourite: true })] })
+      );
+    await flush();
+    expect((panel as any)._sessions[0].favourite).toBe(true);
+  });
+
+  it('DEF-PANE-351 - the star a toggle wrote on a row a poll had since replaced is drawn', async () => {
+    // The context menu holds the row it opened on; a poll drawn while it is
+    // open replaces every row object.
+    const opened = session({ name: 'alpha' });
+    render(panel, [opened]);
+    request.mockResolvedValueOnce({ sessions: [session({ name: 'alpha' })] });
+    await (panel as any)._fetch();
+    const held = holdListings({ favourite: true });
+    await (panel as any)._toggleFavourite(opened);
+    held.forEach(answer =>
+      answer({ sessions: [session({ name: 'alpha', favourite: true })] })
+    );
+    await flush();
+    expect((panel as any)._sessions[0].favourite).toBe(true);
+  });
+
+  it('DEF-PANE-351 - a favourite toggle keeps the listing a Launcher tile click asked for', async () => {
+    const alpha = session({ name: 'alpha' });
+    render(panel, [
+      alpha,
+      session({ name: 'beta', session_id: 'sid-beta-old' })
+    ]);
+    const held = holdListings({ favourite: true, argv: ['testbed'] });
+    const tile = (panel as any)._launchIn('/home/user/beta');
+    await (panel as any)._toggleFavourite(alpha);
+    held[0]({
+      sessions: [alpha, session({ name: 'beta', session_id: 'sid-beta-new' })]
+    });
+    await tile;
+    const call = request.mock.calls.find(c => c[1] === 'launch-argv')!;
+    expect(JSON.parse(call[3].body).session_id).toBe('sid-beta-new');
+  });
+
   it('DEF-PANE-346 - waits with a redraw while a button is pressed in the list, until the click has been sent', async () => {
     const names = (): string[] =>
       Array.from(

package/src/__tests__/terminals.spec.ts

@@ -208,6 +208,26 @@ describe('terminal reuse', () => {
 
     expect(launches).toHaveLength(0);
   });
+
+  it('does not reuse the terminal it launched once its process runs another conversation', async () => {
+    manager = makeManager();
+    manager.setSessions([session()]);
+    await manager.openSession(session(), undefined, CURRENT);
+    expect(launches).toHaveLength(1);
+    // /clear in that terminal: its process now runs a new conversation.
+    probes['launched-1'] = {
+      ...READABLE,
+      terminal_name: 'launched-1',
+      session_id: 'session-22222222-2222-4222-8222-222222222222'
+    };
+    const activated = jest.spyOn((manager as any)._app.shell, 'activateById');
+
+    await manager.openSession(session(), undefined, CURRENT);
+
+    expect(request.mock.calls.map(c => c[1])).toContain('terminal/launched-1');
+    expect(launches).toHaveLength(2);
+    expect(activated).not.toHaveBeenCalledWith('id-0001');
+  });
 });
 
 describe('one spinner dialog (DEF-PANE-327-BUSY-MODAL-1)', () => {

package/src/core/panel.ts

@@ -14,6 +14,7 @@ import {
   LabIcon,
   MenuSvg,
   closeIcon,
+  copyIcon,
   editIcon,
   folderIcon,
   terminalIcon
@@ -152,8 +153,9 @@ let fileBrowserMoves: Promise<void> = Promise.resolve();
  * later click does not move the file browser, so it ends on the folder of the
  * newest click that opened (DEF-PANE-343). The same counter orders the writes
  * that decide a project's current conversation: a row click, an explicit
- * switch and a fork each take a number, and a row click posts its deferred
- * switch only while it is the newest (DEF-PANE-349). */
+ * switch, a fork and a New Session (+) each take a number, and a row click
+ * posts its deferred switch only while it is the newest (DEF-PANE-349,
+ * DEF-PANE-355). */
 let openClicks = 0;
 let movedClick = 0;
 
@@ -725,7 +727,11 @@ export class AssistantSessionsPanel extends Widget {
       return;
     }
     this._fetchDrawn = request;
-    this._sessions = data.sessions ?? [];
+    // A project removed at or after this listing was sent must not be drawn
+    // back from the answer (DEF-PANE-351-WRITE-ORDER).
+    this._sessions = (data.sessions ?? []).filter(
+      s => (this._removedAt.get(s.encoded_path) ?? 0) < request
+    );
     this._setInlineError(null);
     this._terminals.setSessions(this._sessions);
     this._render();
@@ -750,6 +756,10 @@ export class AssistantSessionsPanel extends Widget {
           })
         }
       );
+      // A listing sent before the write may still be drawn, and a poll may
+      // have replaced the row this wrote; this one is answered after the write
+      // (DEF-PANE-351).
+      void this._fetch().catch(() => undefined);
     } catch (err) {
       session.favourite = !next; // roll back
       this._render();
@@ -812,6 +822,11 @@ export class AssistantSessionsPanel extends Widget {
       this._sessions = (this._sessions ?? []).filter(
         s => s.encoded_path !== session.encoded_path
       );
+      // A listing sent before the delete may still be drawn (DEF-PANE-351),
+      // and it carries the removed project: the number taken here marks the
+      // answer for `_fetch` to drop (DEF-PANE-351-WRITE-ORDER).
+      this._removedAt.set(session.encoded_path, this._fetchSent);
+      void this._fetch().catch(() => undefined);
     } catch (err) {
       this._showActionError(`Could not remove "${name}" - try again.`, err);
     } finally {
@@ -1147,7 +1162,7 @@ export class AssistantSessionsPanel extends Widget {
         // before the server can read the conversation off its process
         // (DEF-PANE-345).
         const found =
-          this._terminals.cached(folder, row.session_id) ??
+          (await this._terminals.cached(folder, row.session_id)) ??
           (await this._terminals.findForSession(row.session_id, folder))
             ?.widget;
         if (found) {
@@ -1230,6 +1245,15 @@ export class AssistantSessionsPanel extends Widget {
     const existing = (this._sessions ?? []).find(
       s => s.project_path === projectPath
     );
+    if (existing) {
+      // The + click is the project's newest decision: a row open still
+      // finishing posts no switch over it (DEF-PANE-355). It has no id to post;
+      // the launch route clears the pin.
+      this._currentTokens.set(existing.encoded_path, {
+        click: ++openClicks,
+        sessionId: ''
+      });
+    }
     // Raised on the click, not by the launch: the launch waits for a tile
     // launch clicked before it (DEF-PANE-345).
     const busy = beginSpinner(
@@ -1527,7 +1551,8 @@ export class AssistantSessionsPanel extends Widget {
     const run = (this._switchChains.get(key) ?? Promise.resolve()).then(
       async () => {
         const newest = this._currentTokens.get(key);
-        if (!newest) {
+        // An empty id is a New Session (+) decision, which posts nothing.
+        if (!newest?.sessionId) {
           return;
         }
         if (!force && this._postedClicks.get(key) === newest.click) {
@@ -2434,6 +2459,7 @@ export class AssistantSessionsPanel extends Widget {
 
     this._commands.addCommand(this._cmd('copy-path'), {
       label: this._trans.__('Copy Path'),
+      icon: copyIcon,
       execute: () => {
         const s = active();
         if (s) {
@@ -2444,6 +2470,7 @@ export class AssistantSessionsPanel extends Widget {
 
     this._commands.addCommand(this._cmd('copy-session-id'), {
       label: this._trans.__('Copy Session ID'),
+      icon: copyIcon,
       execute: () => {
         const id = active()?.session_id;
         if (id) {
@@ -2485,6 +2512,9 @@ export class AssistantSessionsPanel extends Widget {
       // item beside an ordinary one (DEF-45). The sweep variant of the trash
       // glyph, because this one deletes several at once.
       icon: cleanupIcon,
+      // Both history-deleting entries draw their icon in the error colour
+      // (base.css).
+      className: 'jp-AiAssistantsContextMenu-danger',
       isVisible: () => (active()?.extra_sessions ?? 0) > 0,
       execute: () => {
         const s = active();
@@ -2585,6 +2615,7 @@ export class AssistantSessionsPanel extends Widget {
     this._commands.addCommand(this._cmd('remove'), {
       label: `Remove from ${this._descriptor.label}`,
       icon: removeIcon,
+      className: 'jp-AiAssistantsContextMenu-danger',
       execute: () => {
         const s = active();
         if (s) {
@@ -3045,6 +3076,10 @@ export class AssistantSessionsPanel extends Widget {
    * `_fetch`. */
   private _fetchSent = 0;
   private _fetchDrawn = 0;
+  /** The `_fetchSent` number at each removal's DELETE, by encoded path. A
+   * listing sent before that number may still carry the removed project, so
+   * `_fetch` drops it (DEF-PANE-351-WRITE-ORDER). */
+  private readonly _removedAt = new Map<string, number>();
   /** A button is pressed in the list, and a redraw waits for its release -
    * see `_onRelease`. */
   private _pressed = false;

package/src/core/terminals.ts

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

package/src/index.ts

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

package/style/base.css

@@ -713,6 +713,19 @@ body[data-jp-theme-light='true'] .jp-AiAssistantsPanel-dotHalo {
   margin: 0 auto;
 }
 
+/* The two entries that delete history (Clean Up Parallel Sessions, Remove
+   from ...) carry this class from their command options. Label and glyph are
+   red, also while selected: JupyterLab's selected rule sets only the row's
+   background, so the colour holds and the selection background stays every
+   entry's. */
+.jp-AiAssistantsContextMenu-danger {
+  color: var(--jp-error-color1);
+}
+
+.jp-AiAssistantsContextMenu-danger .jp-icon3[fill] {
+  fill: var(--jp-error-color1);
+}
+
 /* ============================================================
    Manage Sessions popup - driven entirely by JupyterLab theme variables so a
    theme flip (light / dark / custom) restyles the whole screen at once. The