jupyterlab_ai_code_assistants_extension 1.2.83 → 1.2.105

package/lib/core/panel.d.ts

@@ -45,6 +45,10 @@ export declare class AssistantSessionsPanel extends Widget {
     protected onBeforeHide(_msg: Message): void;
     protected onCloseRequest(msg: Message): void;
     private _buildShell;
+    /** Raise the click-time busy overlay. Counted, because an open and a branch
+     * can overlap; the overlay clears when the last one ends. */
+    private _beginBusy;
+    private _endBusy;
     /** Show / hide the filter input. Hiding also clears the active filter, so
      * the user never returns to an "invisible" filter narrowing the rows. */
     private _toggleFilterBar;
@@ -302,6 +306,9 @@ export declare class AssistantSessionsPanel extends Widget {
     private readonly _removingPaths;
     private _bodyEl;
     private _loadingEl;
+    private _busyEl;
+    private _busyTextEl;
+    private _busyCount;
     private _errorEl;
     private _refreshBtn;
     private _filterBtn;

package/lib/core/panel.js

@@ -112,6 +112,9 @@ export class AssistantSessionsPanel extends Widget {
         this._deleteToTrash = true;
         this._removingPaths = new Set();
         this._loadingEl = null;
+        this._busyEl = null;
+        this._busyTextEl = null;
+        this._busyCount = 0;
         this._errorEl = null;
         this._refreshBtn = null;
         this._filterBtn = null;
@@ -183,7 +186,13 @@ export class AssistantSessionsPanel extends Widget {
         return this._descriptor;
     }
     dispose() {
+        var _a;
         this._stopPolling();
+        // The busy overlay lives on the shell, outside this widget's tree, so
+        // removing the panel does not remove it. Left behind it would show a
+        // spinner for a panel that no longer exists.
+        (_a = this._busyEl) === null || _a === void 0 ? void 0 : _a.remove();
+        this._busyEl = null;
         // Disabling a provider must leave its running terminals alive and only
         // drop the tint this panel applied.
         void this._terminals.clearColours();
@@ -389,6 +398,31 @@ export class AssistantSessionsPanel extends Widget {
         loadingSpinner.className =
             'jp-aiAssistants-spinner jp-AiAssistantsPanel-loadingSpinner';
         loading.appendChild(loadingSpinner);
+        // Click-time busy overlay: raised synchronously when a row is opened or
+        // branched, before the terminal probe or the branch request, so the click
+        // never reads as ignored (DEF-PANE-318). It sits on the LAB SHELL, not on
+        // the panel: the feedback belongs in the main working area, where the
+        // launch spinner appears, and a panel that is hidden or scrolled must not
+        // keep it out of sight (DEF-PANE-318-1). It takes no pointer events and no
+        // focus: the context menu that launched a branch stays open until its
+        // command runs, and a focus change would close it.
+        const busy = document.createElement('div');
+        busy.className = 'jp-AiAssistants-busyOverlay';
+        busy.hidden = true;
+        const busySpinner = document.createElement('div');
+        busySpinner.className =
+            'jp-aiAssistants-spinner jp-AiAssistants-busySpinner';
+        busySpinner.setAttribute('aria-hidden', 'true');
+        busy.appendChild(busySpinner);
+        // The spinner is decoration; a screen-reader user hears the action
+        // instead. The region sits on the root, always rendered and outside the
+        // overlay and the aria-busy body: a live region created inside a
+        // display:none container, or one whose update lands in an aria-busy
+        // subtree, can be withheld by assistive technology.
+        const busyText = document.createElement('div');
+        busyText.className = 'jp-AiAssistantsPanel-srOnly';
+        busyText.setAttribute('role', 'status');
+        busyText.setAttribute('aria-live', 'polite');
         // Inline error strip - a failed poll reports here and keeps retrying,
         // rather than tearing the panel down or raising a modal that would also
         // interrupt the other providers' panels.
@@ -403,10 +437,44 @@ export class AssistantSessionsPanel extends Widget {
         root.appendChild(error);
         root.appendChild(body);
         root.appendChild(loading);
+        root.appendChild(busyText);
+        // The shell carries the visible feedback; the panel carries the
+        // announcement.
+        this._app.shell.node.appendChild(busy);
         this._bodyEl = body;
         this._loadingEl = loading;
+        this._busyEl = busy;
+        this._busyTextEl = busyText;
         this._errorEl = error;
     }
+    /** Raise the click-time busy overlay. Counted, because an open and a branch
+     * can overlap; the overlay clears when the last one ends. */
+    _beginBusy(message) {
+        this._busyCount += 1;
+        if (this._busyEl) {
+            this._busyEl.hidden = false;
+            if (this._busyTextEl) {
+                this._busyTextEl.textContent = message;
+            }
+            // The body is what the action changes; the root stays outside the
+            // busy subtree so the live region above is not withheld.
+            if (this._bodyEl) {
+                this._bodyEl.setAttribute('aria-busy', 'true');
+            }
+        }
+    }
+    _endBusy() {
+        this._busyCount = Math.max(0, this._busyCount - 1);
+        if (this._busyCount === 0 && this._busyEl) {
+            this._busyEl.hidden = true;
+            if (this._busyTextEl) {
+                this._busyTextEl.textContent = '';
+            }
+            if (this._bodyEl) {
+                this._bodyEl.removeAttribute('aria-busy');
+            }
+        }
+    }
     /** Show / hide the filter input. Hiding also clears the active filter, so
      * the user never returns to an "invisible" filter narrowing the rows. */
     _toggleFilterBar() {
@@ -746,6 +814,9 @@ export class AssistantSessionsPanel extends Widget {
         return resolveLaunchMode(this._descriptor.launchModes, this._modes, force);
     }
     async _openSession(session, force, sessionId) {
+        // The click's own feedback, raised before the terminal walk and the
+        // launch - both can take seconds (DEF-PANE-318).
+        this._beginBusy(this._trans.__('Opening conversation'));
         try {
             await this._terminals.openSession(session, this._launchMode(force), sessionId);
             // Not awaited: the open has succeeded, and the sync is not part of it.
@@ -760,6 +831,7 @@ export class AssistantSessionsPanel extends Widget {
             }
         }
         finally {
+            this._endBusy();
             // Reuse or fresh launch, either way the picture changed. Pull fresh
             // state; a poll tick retries if this one fails.
             void this._fetch().catch(() => undefined);
@@ -894,7 +966,10 @@ export class AssistantSessionsPanel extends Widget {
             if (row) {
                 // A terminal already holding that conversation IS the answer: a second
                 // process on one history is never what the click meant (ACC-LNCH-152).
-                const found = await this._terminals.findForSession(row.session_id);
+                // The folder is required as well: a transcript re-homed into another
+                // project keeps its id, and that terminal is not this folder's
+                // (DEF-PANE-319).
+                const found = await this._terminals.findForSession(row.session_id, folder);
                 if (found) {
                     this._terminals.focus(found.widget);
                     return found.widget;
@@ -985,7 +1060,16 @@ export class AssistantSessionsPanel extends Widget {
         if (!session) {
             return;
         }
-        await this._branchByServerCopy(session, undefined, force);
+        // Raised on the click: the branch POST mints the fork server-side (for
+        // Claude and Codex by running their own CLI) and can take seconds
+        // (DEF-PANE-318).
+        this._beginBusy(this._trans.__('Branching conversation'));
+        try {
+            await this._branchByServerCopy(session, undefined, force);
+        }
+        finally {
+            this._endBusy();
+        }
     }
     /** The server mints the new id and answers with it before the terminal
      * opens - `server-copy` copies the store entry, `server-native` drives the
@@ -1147,7 +1231,6 @@ export class AssistantSessionsPanel extends Widget {
     }
     /** Make another conversation the row's current one. */
     async _switchBranch(session, sessionId) {
-        var _a;
         try {
             const result = await requestProvider(this._descriptor.id, 'switch', this._serverSettings, {
                 method: 'POST',
@@ -1159,15 +1242,6 @@ export class AssistantSessionsPanel extends Widget {
             if (result.current !== result.requested) {
                 Notification.warning('That conversation could not be made the current one.', { autoClose: 4000 });
             }
-            else {
-                // The re-render is the only other signal, and it can read as the
-                // opposite of success: the row now reports the conversation's true
-                // last activity, so switching to an old one dims the row and drops
-                // it out of Recent (DEF-PANE-181).
-                const target = this._lastBranches.find(b => b.session_id === sessionId);
-                const label = (_a = target === null || target === void 0 ? void 0 : target.label) !== null && _a !== void 0 ? _a : shortSessionId(sessionId, this._descriptor.sessionIdPrefix);
-                Notification.success(`${this._lookupName(session)}: switched to ${label}`, { autoClose: 3000 });
-            }
         }
         catch (err) {
             Notification.error(isResponseStatus(err, 404)

package/lib/core/terminals.d.ts

@@ -56,18 +56,26 @@ export declare class TerminalManager {
      * widget is attached and visible.
      */
     focus(widget: any): void;
-    /** Find an open terminal running exactly this conversation, or null.
+    /** Find an open terminal running exactly this conversation in this project,
+     * or null.
      *
-     * Matches on the conversation id ALONE. The server reads the true id from
-     * the running process, so a session the user started by hand is recognised
-     * too, not only launches that carry an argv id. An id is globally unique to
-     * one conversation, so a terminal holding it IS the one to focus, whatever
-     * cwd it reports - a process that changed directory, or whose project dir
-     * was recreated, must still be reused rather than duplicated. */
-    findForSession(wantedSessionId: string | undefined): Promise<{
+     * The server reads the true id from the running process, so a session the
+     * user started by hand is recognised too, not only launches that carry an
+     * argv id. The terminal must ALSO work in the requested project. An id is
+     * not globally unique in the store: Claude re-homes a transcript into a
+     * second project under the same id, so an id match alone can name a process
+     * running it from another tree, and reusing that one opens nothing in the
+     * folder the user clicked (DEF-PANE-319). A process that changed directory
+     * WITHIN the project still matches - the probe lists every cwd in its
+     * tree. */
+    findForSession(wantedSessionId: string | undefined, projectPath: string): Promise<{
         widget: any;
         runningId: string | null;
     } | null>;
+    /** Whether any process in the terminal's tree works in `projectPath` or a
+     * directory under it. No cwds means nothing to prove the terminal belongs
+     * to this project, so it is not reused. */
+    private _runsInProject;
     /** Ask the server what a terminal is running. Null when the widget has no
      * session name yet, or the probe fails - a terminal can vanish between
      * enumeration and probe, which is a retry, not an error. */

package/lib/core/terminals.js

@@ -184,8 +184,9 @@ export class TerminalManager {
             this.focus(cached.widget);
             return;
         }
-        // 2. Walk every live terminal, asking the server what each is running.
-        const found = await this.findForSession(wanted);
+        // 2. Walk every live terminal, asking the server what each is running in
+        // this project.
+        const found = await this.findForSession(wanted, session.project_path);
         if (found) {
             // Tag with the OBSERVED conversation, so a later reuse trusts a
             // confirmed identity rather than a wish.
@@ -255,26 +256,43 @@ export class TerminalManager {
             }
         });
     }
-    /** Find an open terminal running exactly this conversation, or null.
+    /** Find an open terminal running exactly this conversation in this project,
+     * or null.
      *
-     * Matches on the conversation id ALONE. The server reads the true id from
-     * the running process, so a session the user started by hand is recognised
-     * too, not only launches that carry an argv id. An id is globally unique to
-     * one conversation, so a terminal holding it IS the one to focus, whatever
-     * cwd it reports - a process that changed directory, or whose project dir
-     * was recreated, must still be reused rather than duplicated. */
-    async findForSession(wantedSessionId) {
+     * The server reads the true id from the running process, so a session the
+     * user started by hand is recognised too, not only launches that carry an
+     * argv id. The terminal must ALSO work in the requested project. An id is
+     * not globally unique in the store: Claude re-homes a transcript into a
+     * second project under the same id, so an id match alone can name a process
+     * running it from another tree, and reusing that one opens nothing in the
+     * folder the user clicked (DEF-PANE-319). A process that changed directory
+     * WITHIN the project still matches - the probe lists every cwd in its
+     * tree. */
+    async findForSession(wantedSessionId, projectPath) {
         if (!this._tracker || !wantedSessionId) {
             return null;
         }
         for (const widget of this._liveTerminals()) {
             const info = await this.probe(widget);
-            if (info && info.session_id && info.session_id === wantedSessionId) {
+            if (info &&
+                info.session_id &&
+                info.session_id === wantedSessionId &&
+                this._runsInProject(info.cwds, projectPath)) {
                 return { widget, runningId: info.session_id };
             }
         }
         return null;
     }
+    /** Whether any process in the terminal's tree works in `projectPath` or a
+     * directory under it. No cwds means nothing to prove the terminal belongs
+     * to this project, so it is not reused. */
+    _runsInProject(cwds, projectPath) {
+        const root = projectPath.replace(/\/+$/, '');
+        return (cwds !== null && cwds !== void 0 ? cwds : []).some(cwd => {
+            const path = cwd.replace(/\/+$/, '');
+            return path === root || path.startsWith(`${root}/`);
+        });
+    }
     /** Ask the server what a terminal is running. Null when the widget has no
      * session name yet, or the probe fails - a terminal can vanish between
      * enumeration and probe, which is a retry, not an error. */

package/package.json

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

@@ -110,7 +110,8 @@ describe('DEF-GUARD-139 - reconcile hands a late roster to a docked panel', () =
     const app = {
       serviceManager: { serverSettings: {} },
       commands: new CommandRegistry(),
-      hasPlugin: () => false
+      hasPlugin: () => false,
+      shell: { node: document.createElement('div') }
     } as any;
     const settings = {
       raw: '{}',
@@ -213,7 +214,8 @@ describe('ACC-LNCH-143..146 - the Launcher tile has the panel lifecycle', () =>
     const app = {
       serviceManager: { serverSettings: {} },
       commands: new CommandRegistry(),
-      hasPlugin: () => false
+      hasPlugin: () => false,
+      shell: { node: document.createElement('div') }
     } as any;
     const labShell = {
       add: (widget: AssistantSessionsPanel) => docked.push(widget)
@@ -288,7 +290,8 @@ describe('ACC-LNCH-143..146 - the Launcher tile has the panel lifecycle', () =>
       {
         serviceManager: { serverSettings: {} },
         commands: new CommandRegistry(),
-        hasPlugin: () => false
+        hasPlugin: () => false,
+        shell: { node: document.createElement('div') }
       } as any,
       { add: (widget: AssistantSessionsPanel) => docked.push(widget) } as any,
       null,
@@ -416,7 +419,8 @@ describe('ACC-PROV - the activation contract', () => {
     const app = {
       serviceManager: { serverSettings },
       commands: new CommandRegistry(),
-      hasPlugin: () => false
+      hasPlugin: () => false,
+      shell: { node: document.createElement('div') }
     } as any;
 
     const composite = options.composite;
@@ -878,6 +882,8 @@ describe('ACC-SETT - settings drive the panels', () => {
     const shellMoves: [string, string][] = [];
     const sequence: string[] = [];
     const labShell = {
+      // The panel mounts its click-time overlay on the shell node.
+      node: document.createElement('div'),
       // As the real sidebar does: a widget is hidden when it is added, and a
       // placement the user made with JupyterLab's own command overrides the
       // area the caller asks for.
@@ -934,7 +940,8 @@ describe('ACC-SETT - settings drive the panels', () => {
     const app = {
       serviceManager: { serverSettings },
       commands,
-      hasPlugin: () => false
+      hasPlugin: () => false,
+      shell: { node: document.createElement('div') }
     } as any;
 
     const changed = new Signal<unknown, void>({});
@@ -1758,7 +1765,8 @@ describe('ACC-RETI-82..84 - a retired standalone extension still installed', ()
     const app = {
       serviceManager: { serverSettings },
       commands: new CommandRegistry(),
-      hasPlugin: (id: string) => installed.includes(id)
+      hasPlugin: (id: string) => installed.includes(id),
+      shell: { node: document.createElement('div') }
     } as any;
     await (plugin.activate as any)(
       app,

package/src/__tests__/launcher.spec.ts

@@ -192,7 +192,10 @@ function harness(
       }
     },
     commands,
-    shell: { activateById: (id: string) => activated.push(id) }
+    shell: {
+      node: document.createElement('div'),
+      activateById: (id: string) => activated.push(id)
+    }
   } as any;
   const panel = new AssistantSessionsPanel({
     app,
@@ -279,7 +282,8 @@ describe('the tile click path resumes a folder that has a conversation', () => {
       'terminal/term-1': {
         terminal_name: 'term-1',
         running: true,
-        session_id: 'sid-proj'
+        session_id: 'sid-proj',
+        cwds: ['/srv/lab/proj']
       }
     });
     const h = harness({ tracker: true });
@@ -291,6 +295,32 @@ describe('the tile click path resumes a folder that has a conversation', () => {
     expect(callsTo('launch-argv')).toHaveLength(0);
   });
 
+  it('launches here when the terminal holds the conversation in another folder', async () => {
+    // DEF-PANE-319: a transcript re-homed into another project keeps its id,
+    // so the id alone cannot prove the terminal is this folder's.
+    routes({
+      sessions: { sessions: [session()] },
+      'terminal/term-1': {
+        terminal_name: 'term-1',
+        running: true,
+        session_id: 'sid-proj',
+        cwds: ['/srv/other']
+      },
+      'launch-argv': { argv: ['/bin/testbed', '--resume', 'sid-proj'] }
+    });
+    const h = harness({ tracker: true });
+    await flush();
+
+    expect(await h.panel.launchHere('proj')).toBe(LAUNCHED_WIDGET);
+    expect(h.activated).not.toContain('terminal-open-1');
+    expect(h.launches).toEqual([
+      {
+        argv: ['/bin/testbed', '--resume', 'sid-proj'],
+        cwd: '/srv/lab/proj'
+      }
+    ]);
+  });
+
   it('asks for resume argv when no terminal holds it, and launches that', async () => {
     // ACC-LNCH-151 / ACC-LNCH-154: the row's own conversation, resumed through
     // the sibling's terminal.
@@ -489,7 +519,8 @@ describe('the tiles the plugin adds to the Launcher', () => {
     const app = {
       serviceManager: { serverSettings: {} },
       commands: new CommandRegistry(),
-      hasPlugin: () => false
+      hasPlugin: () => false,
+      shell: { node: document.createElement('div') }
     } as any;
     const labShell = {
       add: (widget: AssistantSessionsPanel) => docked.push(widget)

package/src/__tests__/panel.spec.ts

@@ -119,16 +119,23 @@ function session(over: Partial<ISession> = {}): ISession {
 function makePanel(
   descriptor: IProviderDescriptor = DESCRIPTOR
 ): AssistantSessionsPanel {
+  const shellNode = document.createElement('div');
   return new AssistantSessionsPanel({
     app: {
       serviceManager: { serverSettings: {} },
-      commands: { execute: jest.fn() }
+      commands: { execute: jest.fn() },
+      shell: { node: shellNode, activateById: jest.fn() }
     } as any,
     descriptor,
     rootDir: '/home/user'
   });
 }
 
+/** The lab-shell node a panel mounts its click-time overlay on. */
+function shellNodeOf(panel: AssistantSessionsPanel): HTMLElement {
+  return (panel as any)._app.shell.node as HTMLElement;
+}
+
 function render(panel: AssistantSessionsPanel, rows: ISession[]): void {
   (panel as any)._sessions = rows;
   (panel as any)._render();
@@ -455,6 +462,148 @@ describe('ACC-SESS-203 - automatic branch names', () => {
   );
 });
 
+describe('click-time busy state (DEF-PANE-318)', () => {
+  it('raises the overlay and the body busy state on the click, before the open settles', async () => {
+    const target = makePanel(DESCRIPTOR);
+    const parent = session();
+    let release!: () => void;
+    const pending = new Promise<void>(resolve => {
+      release = resolve;
+    });
+    (target as any)._terminals.openSession = jest.fn(() => pending);
+    (target as any)._fetch = jest.fn().mockResolvedValue(undefined);
+    const overlay = (): HTMLElement =>
+      shellNodeOf(target).querySelector('.jp-AiAssistants-busyOverlay')!;
+    const body = (): HTMLElement =>
+      target.node.querySelector('.jp-AiAssistantsPanel-body')!;
+
+    const live = target.node.querySelector(
+      '.jp-AiAssistantsPanel-srOnly'
+    ) as HTMLElement;
+    // Rendered at build, not created on demand: the region must be in the
+    // accessibility tree before the click, so its first update is announced.
+    expect(live).not.toBeNull();
+    expect(live.textContent).toBe('');
+    expect(live.getAttribute('role')).toBe('status');
+    expect(live.getAttribute('aria-live')).toBe('polite');
+
+    expect(overlay().hidden).toBe(true);
+    // Shell placement is load-bearing: the feedback belongs in the main
+    // working area, and a panel that is hidden or scrolled must not keep it
+    // out of sight (DEF-PANE-318-1).
+    expect(overlay().parentElement).toBe(shellNodeOf(target));
+    expect(target.node.contains(overlay())).toBe(false);
+    // The overlay takes no focus, so the context menu that launched an action
+    // cannot be closed by an element inside it taking the focus.
+    expect(overlay().hasAttribute('tabindex')).toBe(false);
+    expect(
+      overlay().querySelectorAll(
+        'a[href], button, input, select, textarea, [tabindex]'
+      )
+    ).toHaveLength(0);
+
+    const call = (target as any)._openSession(parent);
+    // The click's own task, before the open settles.
+    expect(overlay().hidden).toBe(false);
+    expect(body().getAttribute('aria-busy')).toBe('true');
+    // Outside both the hidden overlay and the busy body, so assistive
+    // technology is not told to withhold the announcement.
+    expect(live.parentElement).toBe(target.node);
+    expect(body().contains(live)).toBe(false);
+    expect(overlay().contains(live)).toBe(false);
+    expect(live.textContent).toBe('Opening conversation');
+
+    release();
+    await call;
+    expect(overlay().hidden).toBe(true);
+    expect(body().getAttribute('aria-busy')).toBeNull();
+    // Cleared, so an identical action can announce again.
+    expect(live.textContent).toBe('');
+
+    target.dispose();
+  });
+
+  it('keeps the overlay up while a second action is still running', async () => {
+    const target = makePanel(DESCRIPTOR);
+    let releaseFirst!: () => void;
+    let releaseSecond!: () => void;
+    const first = new Promise<void>(resolve => {
+      releaseFirst = resolve;
+    });
+    const second = new Promise<void>(resolve => {
+      releaseSecond = resolve;
+    });
+    const requests = [first, second];
+    (target as any)._terminals.openSession = jest.fn(() => requests.shift());
+    (target as any)._fetch = jest.fn().mockResolvedValue(undefined);
+    const overlay = (): HTMLElement =>
+      shellNodeOf(target).querySelector('.jp-AiAssistants-busyOverlay')!;
+    const body = (): HTMLElement =>
+      target.node.querySelector('.jp-AiAssistantsPanel-body')!;
+
+    const callOne = (target as any)._openSession(
+      session({ session_id: 'one' })
+    );
+    const callTwo = (target as any)._openSession(
+      session({ session_id: 'two' })
+    );
+    expect(overlay().hidden).toBe(false);
+
+    releaseFirst();
+    await callOne;
+    expect(overlay().hidden).toBe(false);
+    expect(body().getAttribute('aria-busy')).toBe('true');
+
+    releaseSecond();
+    await callTwo;
+    expect(overlay().hidden).toBe(true);
+    expect(body().getAttribute('aria-busy')).toBeNull();
+
+    target.dispose();
+  });
+
+  it('announces the branch action while the request is pending', async () => {
+    const target = makePanel(DESCRIPTOR);
+    const parent = session({ name: 'analysis', name_source: 'session' });
+    const launch = jest.fn().mockResolvedValue({});
+    (target as any)._terminals.launch = launch;
+    (target as any)._activeSession = parent;
+    (target as any)._fetch = jest.fn().mockResolvedValue(undefined);
+    let release!: (value: unknown) => void;
+    const pending = new Promise(resolve => {
+      release = resolve;
+    });
+    request.mockImplementation((_provider, path) =>
+      path === 'branch' ? pending : Promise.resolve({})
+    );
+    const body = (): HTMLElement =>
+      target.node.querySelector('.jp-AiAssistantsPanel-body')!;
+    const live = target.node.querySelector(
+      '.jp-AiAssistantsPanel-srOnly'
+    ) as HTMLElement;
+    let call: Promise<void> | undefined;
+    try {
+      call = (target as any)._branchSession();
+      expect(body().getAttribute('aria-busy')).toBe('true');
+      expect(live.textContent).toBe('Branching conversation');
+
+      release({ session_id: 'child' });
+      await call;
+      expect(body().getAttribute('aria-busy')).toBeNull();
+      expect(live.textContent).toBe('');
+    } finally {
+      // A failed assertion must not leave the mock unresolved for the next
+      // test; resolving twice is harmless.
+      release({ session_id: 'child' });
+      if (call) {
+        await call.catch(() => undefined);
+      }
+      target.dispose();
+      request.mockImplementation(() => Promise.resolve({}));
+    }
+  });
+});
+
 describe('a branch whose terminal launch was refused after the mint', () => {
   it('says the branch was created and still lists it when the launch is refused', async () => {
     // The DeepSeek preflight refuses the follow-up launch with a 409 whose
@@ -493,6 +642,15 @@ describe('a branch whose terminal launch was refused after the mint', () => {
     try {
       await (target as any)._branchSession();
 
+      // The refused launch still clears the click-time busy state.
+      expect(
+        (
+          shellNodeOf(target).querySelector(
+            '.jp-AiAssistants-busyOverlay'
+          ) as HTMLElement
+        ).hidden
+      ).toBe(true);
+
       // What the user is told: the branch was created, its terminal did not
       // open, and the refusal's own words - neither sentence that blames the
       // branch itself.
@@ -560,7 +718,8 @@ describe('DEF-132 - a panel docked before the first roster has no root', () => {
     return new AssistantSessionsPanel({
       app: {
         serviceManager: { serverSettings: {} },
-        commands: { execute: jest.fn() }
+        commands: { execute: jest.fn() },
+        shell: { node: document.createElement('div'), activateById: jest.fn() }
       } as any,
       descriptor: { ...DESCRIPTOR, iconName: 'testbed-rootless-panel-spec' },
       rootDir: '',
@@ -749,15 +908,12 @@ describe('DEF-PANE-183 - the status dot follows the name in the DOM', () => {
   });
 });
 
-describe('DEF-PANE-181 - a successful switch says so', () => {
-  it('announces the conversation the project now sits on', async () => {
+describe('DEF-PANE-321 - a successful switch stays quiet', () => {
+  it('issues the switch and raises no notification', async () => {
     const success = jest
       .spyOn(Notification, 'success')
       .mockReturnValue('' as any);
     const target = session({ name: 'proj' });
-    (panel as any)._lastBranches = [
-      { session_id: 'sid-other', file_mtime: 1, label: 'Second thoughts' }
-    ];
     request.mockImplementation((_id: string, route: string) =>
       Promise.resolve(
         route === 'switch'
@@ -766,8 +922,9 @@ describe('DEF-PANE-181 - a successful switch says so', () => {
       )
     );
     await (panel as any)._switchBranch(target, 'sid-other');
-    expect(success).toHaveBeenCalledTimes(1);
-    expect(success.mock.calls[0][0]).toBe('proj: switched to Second thoughts');
+    // The row's own re-render is the only signal a switch earns.
+    expect(request.mock.calls.map(call => call[1])).toContain('switch');
+    expect(success).not.toHaveBeenCalled();
   });
 
   it('stays quiet when the store could not make it current', async () => {
@@ -1703,7 +1860,10 @@ describe('ACC-SESS-190..192 - opening a session moves the file browser', () => {
     const p = new AssistantSessionsPanel({
       app: {
         serviceManager: { serverSettings: {} },
-        shell: { activateById: jest.fn() },
+        shell: {
+          node: document.createElement('div'),
+          activateById: jest.fn()
+        },
         commands: {
           execute: jest.fn(async (id: string) =>
             id === 'terminal:open'
@@ -1787,7 +1947,8 @@ describe('ACC-SESS-190..192 - opening a session moves the file browser', () => {
     const p = new AssistantSessionsPanel({
       app: {
         serviceManager: { serverSettings: {} },
-        commands: { execute: jest.fn() }
+        commands: { execute: jest.fn() },
+        shell: { node: document.createElement('div'), activateById: jest.fn() }
       } as any,
       descriptor: { ...DESCRIPTOR, iconName: 'testbed-rootless-sync-spec' },
       rootDir: ''
@@ -1820,6 +1981,14 @@ describe('ACC-SESS-190..192 - opening a session moves the file browser', () => {
 
     expect(opened).toHaveBeenCalledTimes(1);
     expect(moves(panel)).toEqual([]);
+    // The failed open clears the click-time busy state.
+    expect(
+      (
+        shellNodeOf(panel).querySelector(
+          '.jp-AiAssistants-busyOverlay'
+        ) as HTMLElement
+      ).hidden
+    ).toBe(true);
     // One notification, and it is the one the failed open raises itself.
     expect(notified()).toHaveLength(1);
     expect(notified()[0]).toContain('Could not open that conversation');
@@ -1912,7 +2081,11 @@ describe('ACC-PANE-193 - the panel header has a context menu of its own', () =>
       }
     });
     p = new AssistantSessionsPanel({
-      app: { serviceManager: { serverSettings: {} }, commands } as any,
+      app: {
+        serviceManager: { serverSettings: {} },
+        commands,
+        shell: { node: document.createElement('div'), activateById: jest.fn() }
+      } as any,
       descriptor: { ...DESCRIPTOR, iconName: 'testbed-header-menu-spec' },
       rootDir: '/home/user'
     });

package/src/__tests__/terminals.spec.ts

@@ -26,6 +26,7 @@ import {
 const request = requestProvider as jest.MockedFunction<typeof requestProvider>;
 
 const PROJECT = '/home/user/proj';
+const OTHER_PROJECT = '/home/user/other';
 const CURRENT = 'session-11111111-1111-4111-8111-111111111111';
 
 const DESCRIPTOR: IProviderDescriptor = {
@@ -85,6 +86,8 @@ const RUNNING_PROBE: ITerminalProbeResponse = {
 let terminals: any[];
 let launches: any[];
 let manager: TerminalManager;
+/** Per-terminal probe answers a test wants instead of the defaults below. */
+let probes: Record<string, ITerminalProbeResponse>;
 
 function makeManager(): TerminalManager {
   return new TerminalManager({
@@ -111,6 +114,7 @@ function makeManager(): TerminalManager {
 beforeEach(() => {
   terminals = [];
   launches = [];
+  probes = {};
   request.mockReset();
   request.mockImplementation((async (
     _providerId: string,
@@ -120,6 +124,9 @@ beforeEach(() => {
   ) => {
     if (path.startsWith('terminal/')) {
       const name = decodeURIComponent(path.slice('terminal/'.length));
+      if (probes[name]) {
+        return probes[name];
+      }
       return name === 'running'
         ? RUNNING_PROBE
         : { ...RUNNING_PROBE, terminal_name: name, running: false, cwds: [] };
@@ -140,6 +147,14 @@ afterEach(() => {
 });
 
 describe('terminal reuse', () => {
+  const READABLE: ITerminalProbeResponse = {
+    terminal_name: 'running',
+    running: true,
+    session_id: CURRENT,
+    cwds: [PROJECT],
+    colour: null
+  };
+
   it('never reuses a terminal whose conversation the server cannot read', async () => {
     manager = makeManager();
     manager.setSessions([session()]);
@@ -148,6 +163,43 @@ describe('terminal reuse', () => {
     await manager.openSession(session(), undefined, CURRENT);
 
     expect(launches).toHaveLength(1);
-    expect(await manager.findForSession(CURRENT)).toBeNull();
+    expect(await manager.findForSession(CURRENT, PROJECT)).toBeNull();
+  });
+
+  it('reuses a terminal running this conversation in this project', async () => {
+    manager = makeManager();
+    manager.setSessions([session()]);
+    terminals.push(terminal('running'));
+    probes.running = READABLE;
+
+    await manager.openSession(session(), undefined, CURRENT);
+
+    expect(launches).toHaveLength(0);
+    expect(await manager.findForSession(CURRENT, PROJECT)).not.toBeNull();
+  });
+
+  it('starts a terminal here when the conversation runs in another project', async () => {
+    manager = makeManager();
+    manager.setSessions([session()]);
+    terminals.push(terminal('running'));
+    // Same conversation id, different tree: Claude re-homed a copy of the
+    // transcript into another project, which is DEF-PANE-319's report.
+    probes.running = { ...READABLE, cwds: [OTHER_PROJECT] };
+
+    await manager.openSession(session(), undefined, CURRENT);
+
+    expect(launches).toHaveLength(1);
+    expect(launches[0].project_path).toBe(PROJECT);
+  });
+
+  it('reuses a terminal that changed directory inside the project', async () => {
+    manager = makeManager();
+    manager.setSessions([session()]);
+    terminals.push(terminal('running'));
+    probes.running = { ...READABLE, cwds: [PROJECT, `${PROJECT}/sub`] };
+
+    await manager.openSession(session(), undefined, CURRENT);
+
+    expect(launches).toHaveLength(0);
   });
 });

package/src/core/panel.ts

@@ -235,6 +235,11 @@ export class AssistantSessionsPanel extends Widget {
 
   dispose(): void {
     this._stopPolling();
+    // The busy overlay lives on the shell, outside this widget's tree, so
+    // removing the panel does not remove it. Left behind it would show a
+    // spinner for a panel that no longer exists.
+    this._busyEl?.remove();
+    this._busyEl = null;
     // Disabling a provider must leave its running terminals alive and only
     // drop the tint this panel applied.
     void this._terminals.clearColours();
@@ -467,6 +472,32 @@ export class AssistantSessionsPanel extends Widget {
       'jp-aiAssistants-spinner jp-AiAssistantsPanel-loadingSpinner';
     loading.appendChild(loadingSpinner);
 
+    // Click-time busy overlay: raised synchronously when a row is opened or
+    // branched, before the terminal probe or the branch request, so the click
+    // never reads as ignored (DEF-PANE-318). It sits on the LAB SHELL, not on
+    // the panel: the feedback belongs in the main working area, where the
+    // launch spinner appears, and a panel that is hidden or scrolled must not
+    // keep it out of sight (DEF-PANE-318-1). It takes no pointer events and no
+    // focus: the context menu that launched a branch stays open until its
+    // command runs, and a focus change would close it.
+    const busy = document.createElement('div');
+    busy.className = 'jp-AiAssistants-busyOverlay';
+    busy.hidden = true;
+    const busySpinner = document.createElement('div');
+    busySpinner.className =
+      'jp-aiAssistants-spinner jp-AiAssistants-busySpinner';
+    busySpinner.setAttribute('aria-hidden', 'true');
+    busy.appendChild(busySpinner);
+    // The spinner is decoration; a screen-reader user hears the action
+    // instead. The region sits on the root, always rendered and outside the
+    // overlay and the aria-busy body: a live region created inside a
+    // display:none container, or one whose update lands in an aria-busy
+    // subtree, can be withheld by assistive technology.
+    const busyText = document.createElement('div');
+    busyText.className = 'jp-AiAssistantsPanel-srOnly';
+    busyText.setAttribute('role', 'status');
+    busyText.setAttribute('aria-live', 'polite');
+
     // Inline error strip - a failed poll reports here and keeps retrying,
     // rather than tearing the panel down or raising a modal that would also
     // interrupt the other providers' panels.
@@ -482,12 +513,48 @@ export class AssistantSessionsPanel extends Widget {
     root.appendChild(error);
     root.appendChild(body);
     root.appendChild(loading);
+    root.appendChild(busyText);
+    // The shell carries the visible feedback; the panel carries the
+    // announcement.
+    this._app.shell.node.appendChild(busy);
 
     this._bodyEl = body;
     this._loadingEl = loading;
+    this._busyEl = busy;
+    this._busyTextEl = busyText;
     this._errorEl = error;
   }
 
+  /** Raise the click-time busy overlay. Counted, because an open and a branch
+   * can overlap; the overlay clears when the last one ends. */
+  private _beginBusy(message: string): void {
+    this._busyCount += 1;
+    if (this._busyEl) {
+      this._busyEl.hidden = false;
+      if (this._busyTextEl) {
+        this._busyTextEl.textContent = message;
+      }
+      // The body is what the action changes; the root stays outside the
+      // busy subtree so the live region above is not withheld.
+      if (this._bodyEl) {
+        this._bodyEl.setAttribute('aria-busy', 'true');
+      }
+    }
+  }
+
+  private _endBusy(): void {
+    this._busyCount = Math.max(0, this._busyCount - 1);
+    if (this._busyCount === 0 && this._busyEl) {
+      this._busyEl.hidden = true;
+      if (this._busyTextEl) {
+        this._busyTextEl.textContent = '';
+      }
+      if (this._bodyEl) {
+        this._bodyEl.removeAttribute('aria-busy');
+      }
+    }
+  }
+
   /** Show / hide the filter input. Hiding also clears the active filter, so
    * the user never returns to an "invisible" filter narrowing the rows. */
   private _toggleFilterBar(): void {
@@ -885,6 +952,9 @@ export class AssistantSessionsPanel extends Widget {
     force?: string,
     sessionId?: string
   ): Promise<void> {
+    // The click's own feedback, raised before the terminal walk and the
+    // launch - both can take seconds (DEF-PANE-318).
+    this._beginBusy(this._trans.__('Opening conversation'));
     try {
       await this._terminals.openSession(
         session,
@@ -905,6 +975,7 @@ export class AssistantSessionsPanel extends Widget {
         this._notifyLaunchError('Could not open that conversation', err);
       }
     } finally {
+      this._endBusy();
       // Reuse or fresh launch, either way the picture changed. Pull fresh
       // state; a poll tick retries if this one fails.
       void this._fetch().catch(() => undefined);
@@ -1057,7 +1128,13 @@ export class AssistantSessionsPanel extends Widget {
       if (row) {
         // A terminal already holding that conversation IS the answer: a second
         // process on one history is never what the click meant (ACC-LNCH-152).
-        const found = await this._terminals.findForSession(row.session_id);
+        // The folder is required as well: a transcript re-homed into another
+        // project keeps its id, and that terminal is not this folder's
+        // (DEF-PANE-319).
+        const found = await this._terminals.findForSession(
+          row.session_id,
+          folder
+        );
         if (found) {
           this._terminals.focus(found.widget);
           return found.widget;
@@ -1159,7 +1236,15 @@ export class AssistantSessionsPanel extends Widget {
     if (!session) {
       return;
     }
-    await this._branchByServerCopy(session, undefined, force);
+    // Raised on the click: the branch POST mints the fork server-side (for
+    // Claude and Codex by running their own CLI) and can take seconds
+    // (DEF-PANE-318).
+    this._beginBusy(this._trans.__('Branching conversation'));
+    try {
+      await this._branchByServerCopy(session, undefined, force);
+    } finally {
+      this._endBusy();
+    }
   }
 
   /** The server mints the new id and answers with it before the terminal
@@ -1369,19 +1454,6 @@ export class AssistantSessionsPanel extends Widget {
           'That conversation could not be made the current one.',
           { autoClose: 4000 }
         );
-      } else {
-        // The re-render is the only other signal, and it can read as the
-        // opposite of success: the row now reports the conversation's true
-        // last activity, so switching to an old one dims the row and drops
-        // it out of Recent (DEF-PANE-181).
-        const target = this._lastBranches.find(b => b.session_id === sessionId);
-        const label =
-          target?.label ??
-          shortSessionId(sessionId, this._descriptor.sessionIdPrefix);
-        Notification.success(
-          `${this._lookupName(session)}: switched to ${label}`,
-          { autoClose: 3000 }
-        );
       }
     } catch (err) {
       Notification.error(
@@ -2785,6 +2857,9 @@ export class AssistantSessionsPanel extends Widget {
   private readonly _removingPaths: Set<string> = new Set();
   private _bodyEl!: HTMLDivElement;
   private _loadingEl: HTMLElement | null = null;
+  private _busyEl: HTMLElement | null = null;
+  private _busyTextEl: HTMLElement | null = null;
+  private _busyCount = 0;
   private _errorEl: HTMLElement | null = null;
   private _refreshBtn: HTMLButtonElement | null = null;
   private _filterBtn: HTMLButtonElement | null = null;

package/src/core/terminals.ts

@@ -199,8 +199,9 @@ export class TerminalManager {
       return;
     }
 
-    // 2. Walk every live terminal, asking the server what each is running.
-    const found = await this.findForSession(wanted);
+    // 2. Walk every live terminal, asking the server what each is running in
+    // this project.
+    const found = await this.findForSession(wanted, session.project_path);
     if (found) {
       // Tag with the OBSERVED conversation, so a later reuse trusts a
       // confirmed identity rather than a wish.
@@ -282,29 +283,53 @@ export class TerminalManager {
     });
   }
 
-  /** Find an open terminal running exactly this conversation, or null.
+  /** Find an open terminal running exactly this conversation in this project,
+   * or null.
    *
-   * Matches on the conversation id ALONE. The server reads the true id from
-   * the running process, so a session the user started by hand is recognised
-   * too, not only launches that carry an argv id. An id is globally unique to
-   * one conversation, so a terminal holding it IS the one to focus, whatever
-   * cwd it reports - a process that changed directory, or whose project dir
-   * was recreated, must still be reused rather than duplicated. */
+   * The server reads the true id from the running process, so a session the
+   * user started by hand is recognised too, not only launches that carry an
+   * argv id. The terminal must ALSO work in the requested project. An id is
+   * not globally unique in the store: Claude re-homes a transcript into a
+   * second project under the same id, so an id match alone can name a process
+   * running it from another tree, and reusing that one opens nothing in the
+   * folder the user clicked (DEF-PANE-319). A process that changed directory
+   * WITHIN the project still matches - the probe lists every cwd in its
+   * tree. */
   async findForSession(
-    wantedSessionId: string | undefined
+    wantedSessionId: string | undefined,
+    projectPath: string
   ): Promise<{ widget: any; runningId: string | null } | null> {
     if (!this._tracker || !wantedSessionId) {
       return null;
     }
     for (const widget of this._liveTerminals()) {
       const info = await this.probe(widget);
-      if (info && info.session_id && info.session_id === wantedSessionId) {
+      if (
+        info &&
+        info.session_id &&
+        info.session_id === wantedSessionId &&
+        this._runsInProject(info.cwds, projectPath)
+      ) {
         return { widget, runningId: info.session_id };
       }
     }
     return null;
   }
 
+  /** Whether any process in the terminal's tree works in `projectPath` or a
+   * directory under it. No cwds means nothing to prove the terminal belongs
+   * to this project, so it is not reused. */
+  private _runsInProject(
+    cwds: string[] | undefined,
+    projectPath: string
+  ): boolean {
+    const root = projectPath.replace(/\/+$/, '');
+    return (cwds ?? []).some(cwd => {
+      const path = cwd.replace(/\/+$/, '');
+      return path === root || path.startsWith(`${root}/`);
+    });
+  }
+
   /** Ask the server what a terminal is running. Null when the widget has no
    * session name yet, or the probe fails - a terminal can vanish between
    * enumeration and probe, which is a retry, not an error. */

package/style/base.css

@@ -559,6 +559,13 @@ body[data-jp-theme-light='true'] .jp-AiAssistantsPanel-dotHalo {
     animation: none;
     opacity: 0.5;
   }
+
+  /* The click-time busy spinner is the only thing on screen while a click is
+     being handled, so it keeps full opacity: dimmed, its brand arc measures
+     1.74:1 on the light panel, below the 3:1 minimum for a non-text cue. */
+  .jp-AiAssistants-busySpinner {
+    opacity: 1;
+  }
 }
 
 /* Full-panel veil shown only during an explicit refresh (refresh button or
@@ -581,6 +588,28 @@ body[data-jp-theme-light='true'] .jp-AiAssistantsPanel-dotHalo {
   border-width: 3px;
 }
 
+/* Click-time busy overlay (DEF-PANE-318): raised on the click, before the
+   terminal probe or the branch request. It lives on the lab shell so the
+   feedback appears in the main working area, not inside the panel
+   (DEF-PANE-318-1). No pointer events and no focus - the context menu that
+   launched a branch stays open until its command runs, and a focus change
+   would close it. */
+.jp-AiAssistants-busyOverlay:not([hidden]) {
+  position: fixed;
+  inset: 0;
+  z-index: 9;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  pointer-events: none;
+}
+
+.jp-AiAssistants-busySpinner {
+  width: 24px;
+  height: 24px;
+  border-width: 3px;
+}
+
 .jp-AiAssistantsPanel-launchOverlay {
   display: flex;
   flex-direction: column;
@@ -740,7 +769,7 @@ body[data-jp-theme-light='true'] .jp-AiAssistantsPanel-dotHalo {
   border-radius: var(--aica-radius-lg);
 }
 
-/* Visually hidden polite live region (delete announcements). */
+/* Visually hidden polite live region (polite announcements). */
 .jp-AiAssistantsPanel-srOnly {
   position: absolute;
   width: 1px;