jupyterlab_ai_code_assistants_extension 1.2.105 → 1.2.118

package/README.md

@@ -37,7 +37,7 @@ Chat-panel extensions re-implement the agent loop and trail the real tool. This
 - **Branch session** - fork the current conversation into a new named session via the right-click menu; each assistant forks its own way (Claude's native `--fork-session`, Codex's app-server `thread/fork`, server-side copies for Kimi, Gemini and DeepSeek) behind the same menu item
 - **Rename session** - name a conversation from the right-click menu, and the name is written where the assistant itself reads it back: Claude gets the record its own `/rename` writes, Kimi a custom title, Gemini the chat's summary, DeepSeek its title event. The panel shows the name the assistant actually kept. Codex's name is set through Codex's own app-server, so its CLI lists the same name the panel shows
 - **Launch modes under each assistant's own name** - Claude's skip-permissions, Codex's approval bypass, Kimi's `--yolo`, Gemini's YOLO; unsafe variants carry a shield glyph in the launch menus
-- **Coloured terminal tabs** - each session's colour tints its terminal tab via the companion `jupyterlab_colourful_tab_extension` (installed automatically). Claude's own `/color` supplies its default, Kimi derives a stable colour from the conversation id; Codex, Gemini and DeepSeek have no colour of their own until you set one, and a branched session inherits its parent's colour, which it keeps even if the parent's colour later changes or is reset. Tinting needs the companion release that reports the colours you pick and lets another extension own a tab - against an older one this extension tints no tabs at all and says so once, and the companion's own right-click colours keep working as they always did
+- **Coloured terminal tabs** - each session's colour tints its terminal tab via the companion `jupyterlab_colourful_tab_extension` (installed automatically). Claude's own `/color` supplies its default, Kimi derives a stable colour from the conversation id; Codex, Gemini and DeepSeek have no colour of their own until you set one, and a branched session inherits its parent's colour, which it keeps even if the parent's colour later changes or is reset. A conversation cleared with `/clear` keeps its colour too: the replacement inherits it, and a colour the replacement already has is kept. Tinting needs the companion release that reports the colours you pick and lets another extension own a tab - against an older one this extension tints no tabs at all and says so once, and the companion's own right-click colours keep working as they always did
 - **Your newest colour choice wins** - set a colour on a terminal tab and the extension remembers it for that conversation, so the tab shows it again when you reopen the conversation. In Claude Code, `/color` is the second way to choose, and whichever you used last wins: a colour picked on the tab after `/color` stays, and running `/color` after a pick takes over again, including `/color` with the same colour or a `/color` reset. `Reset Tab Colour (n)` in the session's right-click menu hands back every colour you set by hand on that project's conversations, and appears once there is one to hand back. Clearing the colour on the tab itself releases it too, for the conversation that terminal is running; `Reset Tab Colour` is the way back for a conversation with no tab open. A Kimi or DeepSeek conversation that has never been resumed cannot be tracked yet, so a colour set on its tab is not kept
 - **Favorites** - star projects you keep coming back to via the right-click menu; favourites from the standalone extensions are migrated on first run
 - **Remove and clean up** - drop a project's history or a project's extra parallel sessions from the right-click menu, confirmation dialog first; removed files honour JupyterLab's "move files to trash" setting
@@ -76,6 +76,23 @@ pip install jupyterlab_ai_code_assistants_extension
 > [!WARNING]
 > `package.json` pins `webpack: 5.106.0` and `chalk: 4.1.2` in both `resolutions` and `overrides`. Do not remove these. webpack `>= 5.106.1` changed its module-federation share identifier format and crashes the unmaintained `license-webpack-plugin` (`split('=')[1].trim()`) that `@jupyterlab/builder` injects into every production build; the duplicate `chalk@2.4.2` pulled by `duplicate-package-checker-webpack-plugin` crashes on Node 24+ in the build-isolation install. Without the pins, `make publish` and CI fail on `python -m build`.
 
+## Agent skill
+
+The wheel ships a session-operations skill for coding agents at `share/jupyter/agents/skills/jupyterlab-ai-code-assistants-extension/SKILL.md`. It covers finding, moving, splitting, renaming and promoting sessions, copying a session into another project under a fresh id, the task-list environment variables, and running Claude Code against Kimi K3 or DeepSeek.
+
+After `pip install`, with the Python that runs the lab:
+
+```bash
+mkdir -p ~/.agents/skills
+ln -s "$(python -c 'import sys; print(sys.prefix)')/share/jupyter/agents/skills/jupyterlab-ai-code-assistants-extension" ~/.agents/skills/jupyterlab-ai-code-assistants-extension
+```
+
+From a clone:
+
+```bash
+ln -s "$PWD/.agents/skills/jupyterlab-ai-code-assistants-extension" ~/.claude/skills/jupyterlab-ai-code-assistants-extension
+```
+
 ## Migrating from the standalone extensions
 
 This package supersedes `jupyterlab_claude_code_extension`, `jupyterlab_codex_extension` and `jupyterlab_kimi_code_extension`. On first run it carries their settings and favourites over automatically, and it never replaces a setting you have already saved in this extension; uninstall the standalones once you are ready:

package/lib/core/colour.d.ts

@@ -32,7 +32,7 @@ export declare function effectiveColour(sessionId: string | null, source: Colour
  * with the representative's colour. */
 export declare function sessionForCwds(cwds: string[], sessions: ISession[]): ISession | null;
 /**
- * Client for one provider's user-set colour store.
+ * Client for one provider's stored colour store, hand-set or inherited.
  *
  * The store is server-side and per provider (`providers/<id>/colours`), so
  * colours survive a reload and one assistant's colours can never be read or
@@ -49,7 +49,7 @@ export declare class ColourStore {
     /** User-set colour for a conversation, from the in-memory cache. */
     get(sessionId: string | null | undefined): string | null;
     /** Whether this conversation's colour is the user's own choice rather than
-     * one it inherited at fork time. Only a hand-set colour is offered for
+     * one it inherited at fork or /clear. Only a hand-set colour is offered for
      * release: dropping an inherited one would un-inherit the branch. */
     isOverride(sessionId: string | null | undefined): boolean;
     /** Whether a write against this conversation is still unanswered - queued
@@ -94,8 +94,8 @@ export declare class ColourStore {
      * The ceiling is per request, so K ops queued behind a dead server wait K
      * times it, not it.
      *
-     * An op must never call `load`, `set` or `forget` - it would wait on a chain
-     * that is waiting on it. */
+     * An op must never call `load`, `set`, `forget` or `inherit` - it would wait
+     * on a chain that is waiting on it. */
     private _run;
     /** Open a write against one or more ids. Counted, not flagged: two writes to
      * one id can be queued at once, and a flag would let the first to settle
@@ -119,6 +119,22 @@ export declare class ColourStore {
      * it is checked for the value that was just written. A server that accepted
      * the request and then failed to persist it would otherwise be believed. */
     set(sessionId: string, colour: string | null): Promise<boolean>;
+    /** Record a colour inherited at `/clear`.
+     *
+     * The terminal process survives `/clear` and starts reporting a NEW
+     * conversation id, so the replacement has no colour of its own. It continues
+     * the conversation it replaced, not a new branch, and takes that
+     * conversation's effective colour over - whether the colour was picked on
+     * the tab or chosen by the assistant. `hand_set` false is what records the
+     * origin: an inherited entry, never a hand-set override, so `isOverride`
+     * leaves it out of the release affordance exactly as a fork's inherited tint
+     * is left out.
+     *
+     * The cache is reconciled from the answer the same way `set` reconciles this
+     * one id: the colour when the answer carries it, and the id in `_overrides`
+     * only when the answer names it there. Answers false when the answer does
+     * not carry the colour. */
+    inherit(sessionId: string, colour: string): Promise<boolean>;
     /** Drop stored colours - conversations that no longer exist, or overrides
      * the user released. One request for the whole list, so a release is never
      * left half applied. Same contract as `set`: the answer is checked for the

package/lib/core/colour.js

@@ -1,8 +1,9 @@
 // Terminal tab tint per conversation.
 //
 // Effective colour, highest wins:
-//   1. user-set     - the write-back store this module keeps, per provider.
-//                     Only entries the server still holds: it releases a pick
+//   1. stored       - the write-back store, hand-set or inherited, that this
+//                     module keeps per provider. Only entries the server still
+//                     holds: it releases a pick
 //                     that the assistant's own later colour command overtook,
 //                     because the newer of the two channels wins (DEF-COLO-306)
 //   2. native       - the conversation's own colour, when the assistant has one
@@ -84,7 +85,7 @@ export function sessionForCwds(cwds, sessions) {
     return best;
 }
 /**
- * Client for one provider's user-set colour store.
+ * Client for one provider's stored colour store, hand-set or inherited.
  *
  * The store is server-side and per provider (`providers/<id>/colours`), so
  * colours survive a reload and one assistant's colours can never be read or
@@ -117,7 +118,7 @@ export class ColourStore {
         return (_a = this._colours.get(sessionId)) !== null && _a !== void 0 ? _a : null;
     }
     /** Whether this conversation's colour is the user's own choice rather than
-     * one it inherited at fork time. Only a hand-set colour is offered for
+     * one it inherited at fork or /clear. Only a hand-set colour is offered for
      * release: dropping an inherited one would un-inherit the branch. */
     isOverride(sessionId) {
         return !!sessionId && this._overrides.has(sessionId);
@@ -188,8 +189,8 @@ export class ColourStore {
      * The ceiling is per request, so K ops queued behind a dead server wait K
      * times it, not it.
      *
-     * An op must never call `load`, `set` or `forget` - it would wait on a chain
-     * that is waiting on it. */
+     * An op must never call `load`, `set`, `forget` or `inherit` - it would wait
+     * on a chain that is waiting on it. */
     _run(op) {
         const result = this._chain.then(op);
         const settled = () => undefined;
@@ -278,6 +279,59 @@ export class ColourStore {
             }
         });
     }
+    /** Record a colour inherited at `/clear`.
+     *
+     * The terminal process survives `/clear` and starts reporting a NEW
+     * conversation id, so the replacement has no colour of its own. It continues
+     * the conversation it replaced, not a new branch, and takes that
+     * conversation's effective colour over - whether the colour was picked on
+     * the tab or chosen by the assistant. `hand_set` false is what records the
+     * origin: an inherited entry, never a hand-set override, so `isOverride`
+     * leaves it out of the release affordance exactly as a fork's inherited tint
+     * is left out.
+     *
+     * The cache is reconciled from the answer the same way `set` reconciles this
+     * one id: the colour when the answer carries it, and the id in `_overrides`
+     * only when the answer names it there. Answers false when the answer does
+     * not carry the colour. */
+    async inherit(sessionId, colour) {
+        if (!sessionId) {
+            return false;
+        }
+        const ids = [sessionId];
+        // Marked before the op is queued, not inside it - see `isPending`.
+        this._openWrite(ids);
+        return this._run(async () => {
+            var _a, _b;
+            try {
+                const data = await requestProvider(this._providerId, 'colours', this._serverSettings, {
+                    method: 'POST',
+                    body: JSON.stringify({
+                        session_id: sessionId,
+                        colour,
+                        hand_set: false
+                    })
+                });
+                if (((_a = data.colours) !== null && _a !== void 0 ? _a : {})[sessionId] !== colour) {
+                    return false;
+                }
+                this._colours.set(sessionId, colour);
+                if (((_b = data.overrides) !== null && _b !== void 0 ? _b : []).includes(sessionId)) {
+                    this._overrides.add(sessionId);
+                }
+                else {
+                    this._overrides.delete(sessionId);
+                }
+                return true;
+            }
+            catch (_err) {
+                return false;
+            }
+            finally {
+                this._closeWrite(ids);
+            }
+        });
+    }
     /** Drop stored colours - conversations that no longer exist, or overrides
      * the user released. One request for the whole list, so a release is never
      * left half applied. Same contract as `set`: the answer is checked for the

package/lib/core/panel.d.ts

@@ -45,10 +45,14 @@ 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. */
+    /** Raise the click-time busy overlay. Each action gets a token, because an
+     * open and a branch can overlap; the overlay clears when the last one ends,
+     * and the label names the newest action still running. */
     private _beginBusy;
     private _endBusy;
+    /** Name the newest still-running action in the visible label and the live
+     * region, so neither keeps naming an action that ended. */
+    private _paintBusyMessage;
     /** 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;
@@ -90,9 +94,9 @@ export declare class AssistantSessionsPanel extends Widget {
     private _logError;
     private _fetch;
     private _toggleFavourite;
-    /** The warning a permanent deletion earns and a trashed one does not - a
-     * trashed conversation is recoverable, and the popup one click away says
-     * so; the same sentence on both would be false half the time. */
+    /** 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;
@@ -307,8 +311,10 @@ export declare class AssistantSessionsPanel extends Widget {
     private _bodyEl;
     private _loadingEl;
     private _busyEl;
+    private _busyLabelEl;
     private _busyTextEl;
-    private _busyCount;
+    private _busySeq;
+    private _busyMessages;
     private _errorEl;
     private _refreshBtn;
     private _filterBtn;

package/lib/core/panel.js

@@ -113,8 +113,10 @@ export class AssistantSessionsPanel extends Widget {
         this._removingPaths = new Set();
         this._loadingEl = null;
         this._busyEl = null;
+        this._busyLabelEl = null;
         this._busyTextEl = null;
-        this._busyCount = 0;
+        this._busySeq = 0;
+        this._busyMessages = new Map();
         this._errorEl = null;
         this._refreshBtn = null;
         this._filterBtn = null;
@@ -414,6 +416,14 @@ export class AssistantSessionsPanel extends Widget {
             'jp-aiAssistants-spinner jp-AiAssistants-busySpinner';
         busySpinner.setAttribute('aria-hidden', 'true');
         busy.appendChild(busySpinner);
+        // The action, named in sight: under a reduced-motion preference the ring
+        // is held still, so the label carries the busy state with no animation.
+        // Hidden from assistive technology because the live region below
+        // announces the same words once.
+        const busyLabel = document.createElement('div');
+        busyLabel.className = 'jp-AiAssistants-busyLabel';
+        busyLabel.setAttribute('aria-hidden', 'true');
+        busy.appendChild(busyLabel);
         // 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
@@ -444,29 +454,40 @@ export class AssistantSessionsPanel extends Widget {
         this._bodyEl = body;
         this._loadingEl = loading;
         this._busyEl = busy;
+        this._busyLabelEl = busyLabel;
         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. */
+    /** Raise the click-time busy overlay. Each action gets a token, because an
+     * open and a branch can overlap; the overlay clears when the last one ends,
+     * and the label names the newest action still running. */
     _beginBusy(message) {
-        this._busyCount += 1;
+        const token = ++this._busySeq;
+        this._busyMessages.set(token, message);
         if (this._busyEl) {
             this._busyEl.hidden = false;
-            if (this._busyTextEl) {
-                this._busyTextEl.textContent = message;
-            }
+            this._paintBusyMessage();
             // 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');
             }
         }
+        return token;
     }
-    _endBusy() {
-        this._busyCount = Math.max(0, this._busyCount - 1);
-        if (this._busyCount === 0 && this._busyEl) {
+    _endBusy(token) {
+        this._busyMessages.delete(token);
+        if (this._busyMessages.size > 0) {
+            // Another action is still running; neither the visible label nor the
+            // live region may keep naming the one that just ended.
+            this._paintBusyMessage();
+            return;
+        }
+        if (this._busyEl) {
             this._busyEl.hidden = true;
+            if (this._busyLabelEl) {
+                this._busyLabelEl.textContent = '';
+            }
             if (this._busyTextEl) {
                 this._busyTextEl.textContent = '';
             }
@@ -475,6 +496,20 @@ export class AssistantSessionsPanel extends Widget {
             }
         }
     }
+    /** Name the newest still-running action in the visible label and the live
+     * region, so neither keeps naming an action that ended. */
+    _paintBusyMessage() {
+        let message = '';
+        for (const active of this._busyMessages.values()) {
+            message = active;
+        }
+        if (this._busyLabelEl) {
+            this._busyLabelEl.textContent = message;
+        }
+        if (this._busyTextEl) {
+            this._busyTextEl.textContent = message;
+        }
+    }
     /** Show / hide the filter input. Hiding also clears the active filter, so
      * the user never returns to an "invisible" filter narrowing the rows. */
     _toggleFilterBar() {
@@ -674,14 +709,18 @@ export class AssistantSessionsPanel extends Widget {
             this._showActionError('Could not toggle favorite - try again.', err);
         }
     }
-    /** The warning a permanent deletion earns and a trashed one does not - a
-     * trashed conversation is recoverable, and the popup one click away says
-     * so; the same sentence on both would be false half the time. */
+    /** 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 ? '' : ' This cannot be undone.';
+        return this._deleteToTrash
+            ? ' A permanent removal cannot be undone.'
+            : ' This cannot be undone.';
     }
     get _disposalVerb() {
-        return this._deleteToTrash ? 'moved to trash' : 'deleted permanently';
+        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;
@@ -816,7 +855,7 @@ export class AssistantSessionsPanel extends Widget {
     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'));
+        const busy = 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.
@@ -831,7 +870,7 @@ export class AssistantSessionsPanel extends Widget {
             }
         }
         finally {
-            this._endBusy();
+            this._endBusy(busy);
             // 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);
@@ -1063,12 +1102,12 @@ export class AssistantSessionsPanel extends Widget {
         // 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'));
+        const busy = this._beginBusy(this._trans.__('Branching conversation'));
         try {
             await this._branchByServerCopy(session, undefined, force);
         }
         finally {
-            this._endBusy();
+            this._endBusy(busy);
         }
     }
     /** The server mints the new id and answers with it before the terminal

package/lib/core/popup.js

@@ -44,9 +44,9 @@ export function showManageSessionsPopup(options) {
     let items = [...options.branches];
     const selected = new Set();
     let deleting = false; // guards the async delete against double invocation
-    // Permanent deletion arms first and executes on the second click; a trashed
-    // deletion is recoverable and goes straight through.
-    const armsFirst = !options.deleteToTrash;
+    // Every deletion arms first and executes on the second click: the trash
+    // setting does not promise the system will accept the move, and a fallback
+    // removal is permanent.
     let armed = false;
     let armTimer = 0;
     const body = document.createElement('div');
@@ -87,7 +87,7 @@ export function showManageSessionsPopup(options) {
     deleteBtn.type = 'button';
     deleteBtn.className = 'jp-AiAssistantsPanel-branchDelete';
     deleteBtn.title = options.deleteToTrash
-        ? 'Deleted conversations move to the trash (recoverable)'
+        ? '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 are removed permanently';
     footer.appendChild(deleteBtn);
     // Plain visual counter (selection, or the last action), beside the button
@@ -336,12 +336,12 @@ export function showManageSessionsPopup(options) {
             return;
         }
         // No confirmation DIALOG here: a second Lumino dialog stacked on this popup
-        // renders detached. A permanent deletion still confirms, in the footer
-        // itself - the first click arms the button, the second executes, and any
-        // selection change or four seconds of hesitation disarms it. A trashed
-        // deletion is recoverable, so it keeps going through on one click, with
-        // the live "N deleted" status and a toast from the caller on failure.
-        if (armsFirst && !armed) {
+        // renders detached. The deletion confirms in the footer itself - the first
+        // click arms the button, the second executes, and any selection change or
+        // four seconds of hesitation disarms it. Every deletion arms, because the
+        // trash setting does not promise the system will accept the move, and a
+        // refused move may remove the conversation permanently or leave it.
+        if (!armed) {
             armed = true;
             window.clearTimeout(armTimer);
             armTimer = window.setTimeout(() => {
@@ -384,9 +384,9 @@ export function showManageSessionsPopup(options) {
             (_a = options.onSync) === null || _a === void 0 ? void 0 : _a.call(options, items);
             render();
             updateControls();
-            const moved = options.deleteToTrash
-                ? `${deleted} moved to trash`
-                : `${deleted} deleted`;
+            // One wording for both outcomes: the client cannot know whether the
+            // trash accepted the move, so it does not claim it did.
+            const moved = `${deleted} deleted`;
             selCount.textContent = moved;
             selCount.classList.add('jp-mod-deleted');
             // Clear then re-set on the next tick so an identical count (two single

package/lib/core/terminals.d.ts

@@ -212,6 +212,7 @@ export declare class TerminalManager {
     private readonly _serverSettings;
     private readonly _claims;
     private readonly _pendingChoices;
+    private readonly _lastPainted;
     private readonly _byProject;
     private readonly _pending;
     private _sessions;

package/lib/core/terminals.js

@@ -98,6 +98,14 @@ export class TerminalManager {
         // pass can read the conversation and file it - and while an entry stands, its
         // terminal is not painted, because painting is what destroys the pick.
         this._pendingChoices = new Map();
+        // The conversation each terminal was last PAINTED from, and the effective
+        // colour it was painted. The probe follows the pidfile, so `/clear` answers
+        // the same widget with a new conversation id; a difference against this
+        // record is what tells an in-place replacement from a terminal that simply
+        // started later, and is the colour the replacement inherits. Pruned by
+        // `clearColours` and `dispose` so a tab that is no longer drawn leaves no
+        // entry behind.
+        this._lastPainted = new Map();
         // Most recent terminal per project, tagged with the conversation it runs so
         // reuse can tell a project's branches apart.
         this._byProject = new Map();
@@ -146,6 +154,9 @@ export class TerminalManager {
         // running. Kept past dispose it would be filed by nothing and would hold a
         // widget reference for the life of the page.
         this._pendingChoices.clear();
+        // Nothing is painted from here on, so the record would only hold widget
+        // ids for the life of the page.
+        this._lastPainted.clear();
     }
     /**
      * Open a conversation, reusing an open terminal only when that terminal is
@@ -378,7 +389,7 @@ export class TerminalManager {
             // terminal whose probe simply failed.
             const disowned = new Set();
             await this._eachAssistantTerminal(async (widget, info) => {
-                var _a, _b, _c, _d, _e, _f, _g, _h;
+                var _a, _b, _c, _d, _e, _f, _g, _h, _j;
                 if (!this._colouredTabs ||
                     this._disposed ||
                     this._pass !== generation) {
@@ -446,7 +457,34 @@ export class TerminalManager {
                 const native = (_f = info.colour) !== null && _f !== void 0 ? _f : (sessionId
                     ? ((_h = (_g = this._sessions.find(s => s.session_id === sessionId)) === null || _g === void 0 ? void 0 : _g.colour) !== null && _h !== void 0 ? _h : null)
                     : null);
-                this._applyColour(widget, effectiveColour(sessionId, this._descriptor.colourSource, this._colours.get(sessionId), native));
+                // The probe follows the pidfile, so an in-place `/clear` answers the
+                // SAME terminal with a NEW conversation id. The replacement continues
+                // the conversation it replaced and takes over the effective colour
+                // that one was wearing - a pick made on the tab or a colour the
+                // assistant chose. A stored colour or an assistant-chosen colour on
+                // the new conversation is its own answer, though: only a bare new id
+                // is filled in, so the old colour never overwrites it.
+                let colour = effectiveColour(sessionId, this._descriptor.colourSource, this._colours.get(sessionId), native);
+                if (sessionId) {
+                    const last = this._lastPainted.get(widget.id);
+                    if (last &&
+                        last.sessionId !== sessionId &&
+                        last.colour !== null &&
+                        this._colours.get(sessionId) === null &&
+                        native === null) {
+                        await this._colours.inherit(sessionId, last.colour);
+                        if (!this._colouredTabs ||
+                            this._disposed ||
+                            this._pass !== generation) {
+                            // Colouring went off, the panel went away or a newer pass took
+                            // over while the write was queued. That pass paints the tabs.
+                            return;
+                        }
+                        colour = (_j = this._colours.get(sessionId)) !== null && _j !== void 0 ? _j : last.colour;
+                    }
+                    this._lastPainted.set(widget.id, { sessionId, colour });
+                }
+                this._applyColour(widget, colour);
             }, widget => disowned.add(widget.id));
             if (this._pass === generation) {
                 // Skipped by an overtaken pass: its view of what is recognised and what
@@ -487,6 +525,10 @@ export class TerminalManager {
         // drawing, which is the same thing `_captureColour` refuses to do while
         // colouring is off.
         this._pendingChoices.clear();
+        // Every terminal this manager still sees is about to be painted null, so
+        // no recorded paint describes what is on screen any more - and a `/clear`
+        // that happened while colouring was off must not be inherited from.
+        this._lastPainted.clear();
         const generation = ++this._pass;
         try {
             await this._eachAssistantTerminal(async (widget) => {

package/lib/index.js

@@ -174,9 +174,9 @@ const plugin = {
                     descriptor: module.descriptor,
                     hooks: module.hooks,
                     rootDir: (_a = status === null || status === void 0 ? void 0 : status.root_dir) !== null && _a !== void 0 ? _a : '',
-                    // Unknown reads as "not trash": the popup then arms its Delete
-                    // button before it executes, which is the only confirmation a
-                    // permanent bulk delete has (DEF-135).
+                    // Unknown reads as "not trash", so the dialogs and the popup
+                    // present the permanent-delete wording rather than promising a
+                    // recoverable move the server never confirmed (DEF-135).
                     deleteToTrash: status ? status.delete_to_trash !== false : false,
                     terminalTracker,
                     fileBrowser,

package/package.json

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

@@ -190,6 +190,32 @@ describe('ColourStore.set', () => {
   });
 });
 
+describe('ColourStore.inherit', () => {
+  // The `/clear` path: the replacement conversation takes the effective colour
+  // of the one it replaced, but as an INHERITED entry. Only a hand-set colour
+  // is offered for release, and releasing this one would strip the branch.
+  const store = () => new ColourStore('claude', {} as any);
+
+  beforeEach(() => request.mockReset());
+
+  it('records the colour as inherited, not as the user own choice', async () => {
+    request.mockResolvedValue({
+      colours: { [SESSION_B]: 'sky' },
+      overrides: []
+    } as any);
+    const colours = store();
+    expect(await colours.inherit(SESSION_B, 'sky')).toBe(true);
+
+    expect(JSON.parse((request.mock.calls[0][3] as any).body)).toEqual({
+      session_id: SESSION_B,
+      colour: 'sky',
+      hand_set: false
+    });
+    expect(colours.get(SESSION_B)).toEqual('sky');
+    expect(colours.isOverride(SESSION_B)).toBe(false);
+  });
+});
+
 describe('ColourStore origins', () => {
   // A stored colour is either the user's own choice or one a fork inherited.
   // Both beat the default; only the first is offered for release, or one click
@@ -525,7 +551,7 @@ describe('sessionForCwds', () => {
  * unrunnable invariant (see `core-neutrality.spec.ts`): by reading the source.
  */
 describe('ColourStore queue re-entrancy', () => {
-  const QUEUED = ['load', 'set', 'forget'];
+  const QUEUED = ['load', 'set', 'forget', 'inherit'];
 
   /** The body of one method, by brace matching from its declaration. */
   const bodyOf = (source: string, name: string): string => {

package/src/__tests__/panel.spec.ts

@@ -213,13 +213,16 @@ describe('DEF-51 - the destructive dialogs open with Cancel under the keyboard',
     expect(request).not.toHaveBeenCalled();
   });
 
-  it('says a deletion cannot be undone only when it is permanent', async () => {
-    // Default: trash is on, and a trashed conversation is recoverable.
+  it('says a deletion may be permanent when the trash might refuse', async () => {
+    // Default: trash is on, but the server falls back to a permanent removal
+    // 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 trash');
-    expect(body).not.toContain('cannot be undone');
+    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');
     pressEnter();
     await done;
 
@@ -562,6 +565,31 @@ describe('click-time busy state (DEF-PANE-318)', () => {
     target.dispose();
   });
 
+  it('names the action still running when an overlapping action ends first', () => {
+    const target = makePanel(DESCRIPTOR);
+    const label = (): HTMLElement =>
+      shellNodeOf(target).querySelector('.jp-AiAssistants-busyLabel')!;
+    const live = (): HTMLElement =>
+      target.node.querySelector('.jp-AiAssistantsPanel-srOnly')!;
+
+    const opening = (target as any)._beginBusy('Opening conversation');
+    const branching = (target as any)._beginBusy('Branching conversation');
+    expect(label().textContent).toBe('Branching conversation');
+    expect(live().textContent).toBe('Branching conversation');
+
+    // The later-started action ends first: the label and the live region must
+    // return to the one that is still running, not keep naming the finished
+    // action.
+    (target as any)._endBusy(branching);
+    expect(label().textContent).toBe('Opening conversation');
+    expect(live().textContent).toBe('Opening conversation');
+
+    (target as any)._endBusy(opening);
+    expect(label().textContent).toBe('');
+    expect(live().textContent).toBe('');
+    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' });

package/src/__tests__/popup.spec.ts

@@ -158,9 +158,22 @@ describe('Manage Sessions popup Delete button (DEF-PANE-307)', () => {
     expect(deleteButton().textContent).toBe('Delete (1)');
   });
 
-  it('deletes without closing the dialog', async () => {
+  it('names the trash outcome without promising recoverability', () => {
+    expect(deleteButton().title).toContain(
+      'a refused move may remove them permanently or leave them in place'
+    );
+  });
+
+  it('arms, then deletes without closing the dialog', async () => {
     checkbox(rows()[1]).click();
-    deleteButton().click();
+    const del = deleteButton();
+    // The trash setting does not promise the system will accept the move, so
+    // the first click arms rather than deletes.
+    del.click();
+    expect(onDelete).not.toHaveBeenCalled();
+    expect(del.textContent).toBe('Confirm delete 1');
+
+    del.click();
     await Promise.resolve();
     expect(onDelete).toHaveBeenCalledWith([FIRST]);
     expect(document.querySelector('.jp-Dialog')).not.toBeNull();

package/src/__tests__/tab-colour-capture.spec.ts

@@ -992,6 +992,102 @@ describe('the paint pass', () => {
   });
 });
 
+describe('a conversation replaced in place by /clear', () => {
+  /** The POSTs that record an inherited colour rather than a pick on a tab. */
+  const inheritPosts = (): Record<string, unknown>[] =>
+    request.mock.calls
+      .filter(
+        call =>
+          call[1] === 'colours' &&
+          (call[3] as RequestInit)?.method === 'POST' &&
+          JSON.parse(String((call[3] as RequestInit).body)).hand_set === false
+      )
+      .map(call => JSON.parse(String((call[3] as RequestInit).body)));
+
+  it('hands the replaced conversation effective colour to the new id', async () => {
+    // A pick on the tab of the conversation that `/clear` replaced. The probe
+    // follows the pidfile, so the next pass answers the same terminal with the
+    // new conversation id and the old colour must carry over.
+    server.colours[SESSION] = 'sky';
+    server.overrides = [SESSION];
+    await store.load();
+
+    await manager.reconcileColours();
+    expect(paints(terminals[0]).pop()).toEqual('sky');
+
+    server.probes['1'] = {
+      terminal_name: '1',
+      running: true,
+      session_id: OTHER_SESSION
+    };
+    await manager.reconcileColours();
+
+    expect(inheritPosts()).toEqual([
+      { session_id: OTHER_SESSION, colour: 'sky', hand_set: false }
+    ]);
+    expect(store.get(OTHER_SESSION)).toEqual('sky');
+    // Inherited, not hand-set: the release affordance must not offer it.
+    expect(store.isOverride(OTHER_SESSION)).toBe(false);
+    expect(paints(terminals[0]).pop()).toEqual('sky');
+  });
+
+  it('leaves a colour the new conversation already answers alone', async () => {
+    // The new conversation already has a stored colour of its own. It is not
+    // bare, so the replaced conversation's colour must not be written over it.
+    server.colours[SESSION] = 'sky';
+    server.overrides = [SESSION];
+    await store.load();
+    await manager.reconcileColours();
+
+    server.colours[OTHER_SESSION] = 'mint';
+    server.overrides = [SESSION, OTHER_SESSION];
+    await store.load();
+    server.probes['1'] = {
+      terminal_name: '1',
+      running: true,
+      session_id: OTHER_SESSION
+    };
+    await manager.reconcileColours();
+
+    expect(inheritPosts()).toEqual([]);
+    expect(paints(terminals[0]).pop()).toEqual('mint');
+  });
+
+  it('does not inherit over a colour the new conversation already answers with', async () => {
+    // The replacement answers the probe with an assistant-chosen colour. That
+    // is the new conversation's own answer even though the store holds nothing
+    // for it, so `native === null` is what keeps the replaced conversation's
+    // colour from overwriting it.
+    //
+    // The descriptor is switched to `native` so the probe's colour reaches the
+    // ladder: under the default `derived` source a native colour is only a
+    // guard input and would never be painted.
+    manager.dispose();
+    manager = makeManager({
+      descriptor: { ...DESCRIPTOR, colourSource: 'native' }
+    });
+
+    server.colours[SESSION] = 'sky';
+    server.overrides = [SESSION];
+    await store.load();
+    await manager.reconcileColours();
+    expect(paints(terminals[0]).pop()).toEqual('sky');
+
+    server.probes['1'] = {
+      terminal_name: '1',
+      running: true,
+      session_id: OTHER_SESSION,
+      colour: 'mint'
+    };
+    await manager.reconcileColours();
+
+    // Nothing was written for the replacement: its own colour outranks the
+    // cleared conversation's, and the tab paints that colour.
+    expect(inheritPosts()).toEqual([]);
+    expect(paints(terminals[0]).pop()).toEqual('mint');
+  });
+});
+
 /** Manager options against one companion, for the isolated-module case that
  * cannot use `makeManager`. */
 function optionsFor(colourfulTabs: unknown): TerminalManager.IOptions {

package/src/core/colour.ts

@@ -1,8 +1,9 @@
 // Terminal tab tint per conversation.
 //
 // Effective colour, highest wins:
-//   1. user-set     - the write-back store this module keeps, per provider.
-//                     Only entries the server still holds: it releases a pick
+//   1. stored       - the write-back store, hand-set or inherited, that this
+//                     module keeps per provider. Only entries the server still
+//                     holds: it releases a pick
 //                     that the assistant's own later colour command overtook,
 //                     because the newer of the two channels wins (DEF-COLO-306)
 //   2. native       - the conversation's own colour, when the assistant has one
@@ -101,7 +102,7 @@ export function sessionForCwds(
 }
 
 /**
- * Client for one provider's user-set colour store.
+ * Client for one provider's stored colour store, hand-set or inherited.
  *
  * The store is server-side and per provider (`providers/<id>/colours`), so
  * colours survive a reload and one assistant's colours can never be read or
@@ -128,7 +129,7 @@ export class ColourStore {
   }
 
   /** Whether this conversation's colour is the user's own choice rather than
-   * one it inherited at fork time. Only a hand-set colour is offered for
+   * one it inherited at fork or /clear. Only a hand-set colour is offered for
    * release: dropping an inherited one would un-inherit the branch. */
   isOverride(sessionId: string | null | undefined): boolean {
     return !!sessionId && this._overrides.has(sessionId);
@@ -206,8 +207,8 @@ export class ColourStore {
    * The ceiling is per request, so K ops queued behind a dead server wait K
    * times it, not it.
    *
-   * An op must never call `load`, `set` or `forget` - it would wait on a chain
-   * that is waiting on it. */
+   * An op must never call `load`, `set`, `forget` or `inherit` - it would wait
+   * on a chain that is waiting on it. */
   private _run<T>(op: () => Promise<T>): Promise<T> {
     const result = this._chain.then(op);
     const settled = () => undefined;
@@ -298,6 +299,61 @@ export class ColourStore {
     });
   }
 
+  /** Record a colour inherited at `/clear`.
+   *
+   * The terminal process survives `/clear` and starts reporting a NEW
+   * conversation id, so the replacement has no colour of its own. It continues
+   * the conversation it replaced, not a new branch, and takes that
+   * conversation's effective colour over - whether the colour was picked on
+   * the tab or chosen by the assistant. `hand_set` false is what records the
+   * origin: an inherited entry, never a hand-set override, so `isOverride`
+   * leaves it out of the release affordance exactly as a fork's inherited tint
+   * is left out.
+   *
+   * The cache is reconciled from the answer the same way `set` reconciles this
+   * one id: the colour when the answer carries it, and the id in `_overrides`
+   * only when the answer names it there. Answers false when the answer does
+   * not carry the colour. */
+  async inherit(sessionId: string, colour: string): Promise<boolean> {
+    if (!sessionId) {
+      return false;
+    }
+    const ids = [sessionId];
+    // Marked before the op is queued, not inside it - see `isPending`.
+    this._openWrite(ids);
+    return this._run(async () => {
+      try {
+        const data = await requestProvider<IColourStoreResponse>(
+          this._providerId,
+          'colours',
+          this._serverSettings,
+          {
+            method: 'POST',
+            body: JSON.stringify({
+              session_id: sessionId,
+              colour,
+              hand_set: false
+            })
+          }
+        );
+        if ((data.colours ?? {})[sessionId] !== colour) {
+          return false;
+        }
+        this._colours.set(sessionId, colour);
+        if ((data.overrides ?? []).includes(sessionId)) {
+          this._overrides.add(sessionId);
+        } else {
+          this._overrides.delete(sessionId);
+        }
+        return true;
+      } catch (_err) {
+        return false;
+      } finally {
+        this._closeWrite(ids);
+      }
+    });
+  }
+
   /** Drop stored colours - conversations that no longer exist, or overrides
    * the user released. One request for the whole list, so a release is never
    * left half applied. Same contract as `set`: the answer is checked for the

package/src/core/panel.ts

@@ -488,6 +488,14 @@ export class AssistantSessionsPanel extends Widget {
       'jp-aiAssistants-spinner jp-AiAssistants-busySpinner';
     busySpinner.setAttribute('aria-hidden', 'true');
     busy.appendChild(busySpinner);
+    // The action, named in sight: under a reduced-motion preference the ring
+    // is held still, so the label carries the busy state with no animation.
+    // Hidden from assistive technology because the live region below
+    // announces the same words once.
+    const busyLabel = document.createElement('div');
+    busyLabel.className = 'jp-AiAssistants-busyLabel';
+    busyLabel.setAttribute('aria-hidden', 'true');
+    busy.appendChild(busyLabel);
     // 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
@@ -521,31 +529,42 @@ export class AssistantSessionsPanel extends Widget {
     this._bodyEl = body;
     this._loadingEl = loading;
     this._busyEl = busy;
+    this._busyLabelEl = busyLabel;
     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;
+  /** Raise the click-time busy overlay. Each action gets a token, because an
+   * open and a branch can overlap; the overlay clears when the last one ends,
+   * and the label names the newest action still running. */
+  private _beginBusy(message: string): number {
+    const token = ++this._busySeq;
+    this._busyMessages.set(token, message);
     if (this._busyEl) {
       this._busyEl.hidden = false;
-      if (this._busyTextEl) {
-        this._busyTextEl.textContent = message;
-      }
+      this._paintBusyMessage();
       // 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');
       }
     }
+    return token;
   }
 
-  private _endBusy(): void {
-    this._busyCount = Math.max(0, this._busyCount - 1);
-    if (this._busyCount === 0 && this._busyEl) {
+  private _endBusy(token: number): void {
+    this._busyMessages.delete(token);
+    if (this._busyMessages.size > 0) {
+      // Another action is still running; neither the visible label nor the
+      // live region may keep naming the one that just ended.
+      this._paintBusyMessage();
+      return;
+    }
+    if (this._busyEl) {
       this._busyEl.hidden = true;
+      if (this._busyLabelEl) {
+        this._busyLabelEl.textContent = '';
+      }
       if (this._busyTextEl) {
         this._busyTextEl.textContent = '';
       }
@@ -555,6 +574,21 @@ export class AssistantSessionsPanel extends Widget {
     }
   }
 
+  /** Name the newest still-running action in the visible label and the live
+   * region, so neither keeps naming an action that ended. */
+  private _paintBusyMessage(): void {
+    let message = '';
+    for (const active of this._busyMessages.values()) {
+      message = active;
+    }
+    if (this._busyLabelEl) {
+      this._busyLabelEl.textContent = message;
+    }
+    if (this._busyTextEl) {
+      this._busyTextEl.textContent = message;
+    }
+  }
+
   /** 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 {
@@ -781,15 +815,19 @@ export class AssistantSessionsPanel extends Widget {
     }
   }
 
-  /** The warning a permanent deletion earns and a trashed one does not - a
-   * trashed conversation is recoverable, and the popup one click away says
-   * so; the same sentence on both would be false half the time. */
+  /** 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 ? '' : ' This cannot be undone.';
+    return this._deleteToTrash
+      ? ' A permanent removal cannot be undone.'
+      : ' This cannot be undone.';
   }
 
   private get _disposalVerb(): string {
-    return this._deleteToTrash ? 'moved to trash' : 'deleted permanently';
+    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> {
@@ -954,7 +992,7 @@ export class AssistantSessionsPanel extends Widget {
   ): 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'));
+    const busy = this._beginBusy(this._trans.__('Opening conversation'));
     try {
       await this._terminals.openSession(
         session,
@@ -975,7 +1013,7 @@ export class AssistantSessionsPanel extends Widget {
         this._notifyLaunchError('Could not open that conversation', err);
       }
     } finally {
-      this._endBusy();
+      this._endBusy(busy);
       // 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);
@@ -1239,11 +1277,11 @@ export class AssistantSessionsPanel extends Widget {
     // 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'));
+    const busy = this._beginBusy(this._trans.__('Branching conversation'));
     try {
       await this._branchByServerCopy(session, undefined, force);
     } finally {
-      this._endBusy();
+      this._endBusy(busy);
     }
   }
 
@@ -2858,8 +2896,10 @@ export class AssistantSessionsPanel extends Widget {
   private _bodyEl!: HTMLDivElement;
   private _loadingEl: HTMLElement | null = null;
   private _busyEl: HTMLElement | null = null;
+  private _busyLabelEl: HTMLElement | null = null;
   private _busyTextEl: HTMLElement | null = null;
-  private _busyCount = 0;
+  private _busySeq = 0;
+  private _busyMessages = new Map<number, string>();
   private _errorEl: HTMLElement | null = null;
   private _refreshBtn: HTMLButtonElement | null = null;
   private _filterBtn: HTMLButtonElement | null = null;

package/src/core/popup.ts

@@ -106,9 +106,9 @@ export function showManageSessionsPopup(
   let items = [...options.branches];
   const selected = new Set<string>();
   let deleting = false; // guards the async delete against double invocation
-  // Permanent deletion arms first and executes on the second click; a trashed
-  // deletion is recoverable and goes straight through.
-  const armsFirst = !options.deleteToTrash;
+  // Every deletion arms first and executes on the second click: the trash
+  // setting does not promise the system will accept the move, and a fallback
+  // removal is permanent.
   let armed = false;
   let armTimer = 0;
 
@@ -154,7 +154,7 @@ export function showManageSessionsPopup(
   deleteBtn.type = 'button';
   deleteBtn.className = 'jp-AiAssistantsPanel-branchDelete';
   deleteBtn.title = options.deleteToTrash
-    ? 'Deleted conversations move to the trash (recoverable)'
+    ? '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 are removed permanently';
   footer.appendChild(deleteBtn);
   // Plain visual counter (selection, or the last action), beside the button
@@ -421,12 +421,12 @@ export function showManageSessionsPopup(
       return;
     }
     // No confirmation DIALOG here: a second Lumino dialog stacked on this popup
-    // renders detached. A permanent deletion still confirms, in the footer
-    // itself - the first click arms the button, the second executes, and any
-    // selection change or four seconds of hesitation disarms it. A trashed
-    // deletion is recoverable, so it keeps going through on one click, with
-    // the live "N deleted" status and a toast from the caller on failure.
-    if (armsFirst && !armed) {
+    // renders detached. The deletion confirms in the footer itself - the first
+    // click arms the button, the second executes, and any selection change or
+    // four seconds of hesitation disarms it. Every deletion arms, because the
+    // trash setting does not promise the system will accept the move, and a
+    // refused move may remove the conversation permanently or leave it.
+    if (!armed) {
       armed = true;
       window.clearTimeout(armTimer);
       armTimer = window.setTimeout(() => {
@@ -467,9 +467,9 @@ export function showManageSessionsPopup(
         options.onSync?.(items);
         render();
         updateControls();
-        const moved = options.deleteToTrash
-          ? `${deleted} moved to trash`
-          : `${deleted} deleted`;
+        // One wording for both outcomes: the client cannot know whether the
+        // trash accepted the move, so it does not claim it did.
+        const moved = `${deleted} deleted`;
         selCount.textContent = moved;
         selCount.classList.add('jp-mod-deleted');
         // Clear then re-set on the next tick so an identical count (two single

package/src/core/terminals.ts

@@ -151,6 +151,9 @@ export class TerminalManager {
     // running. Kept past dispose it would be filed by nothing and would hold a
     // widget reference for the life of the page.
     this._pendingChoices.clear();
+    // Nothing is painted from here on, so the record would only hold widget
+    // ids for the life of the page.
+    this._lastPainted.clear();
   }
 
   /**
@@ -508,15 +511,44 @@ export class TerminalManager {
               ? (this._sessions.find(s => s.session_id === sessionId)?.colour ??
                 null)
               : null);
-          this._applyColour(
-            widget,
-            effectiveColour(
-              sessionId,
-              this._descriptor.colourSource,
-              this._colours.get(sessionId),
-              native
-            )
+
+          // The probe follows the pidfile, so an in-place `/clear` answers the
+          // SAME terminal with a NEW conversation id. The replacement continues
+          // the conversation it replaced and takes over the effective colour
+          // that one was wearing - a pick made on the tab or a colour the
+          // assistant chose. A stored colour or an assistant-chosen colour on
+          // the new conversation is its own answer, though: only a bare new id
+          // is filled in, so the old colour never overwrites it.
+          let colour = effectiveColour(
+            sessionId,
+            this._descriptor.colourSource,
+            this._colours.get(sessionId),
+            native
           );
+          if (sessionId) {
+            const last = this._lastPainted.get(widget.id);
+            if (
+              last &&
+              last.sessionId !== sessionId &&
+              last.colour !== null &&
+              this._colours.get(sessionId) === null &&
+              native === null
+            ) {
+              await this._colours.inherit(sessionId, last.colour);
+              if (
+                !this._colouredTabs ||
+                this._disposed ||
+                this._pass !== generation
+              ) {
+                // Colouring went off, the panel went away or a newer pass took
+                // over while the write was queued. That pass paints the tabs.
+                return;
+              }
+              colour = this._colours.get(sessionId) ?? last.colour;
+            }
+            this._lastPainted.set(widget.id, { sessionId, colour });
+          }
+          this._applyColour(widget, colour);
         },
         widget => disowned.add(widget.id)
       );
@@ -561,6 +593,10 @@ export class TerminalManager {
     // drawing, which is the same thing `_captureColour` refuses to do while
     // colouring is off.
     this._pendingChoices.clear();
+    // Every terminal this manager still sees is about to be painted null, so
+    // no recorded paint describes what is on screen any more - and a `/clear`
+    // that happened while colouring was off must not be inherited from.
+    this._lastPainted.clear();
     const generation = ++this._pass;
     try {
       await this._eachAssistantTerminal(async widget => {
@@ -884,6 +920,17 @@ export class TerminalManager {
   // pass can read the conversation and file it - and while an entry stands, its
   // terminal is not painted, because painting is what destroys the pick.
   private readonly _pendingChoices: Map<string, string | null> = new Map();
+  // The conversation each terminal was last PAINTED from, and the effective
+  // colour it was painted. The probe follows the pidfile, so `/clear` answers
+  // the same widget with a new conversation id; a difference against this
+  // record is what tells an in-place replacement from a terminal that simply
+  // started later, and is the colour the replacement inherits. Pruned by
+  // `clearColours` and `dispose` so a tab that is no longer drawn leaves no
+  // entry behind.
+  private readonly _lastPainted: Map<
+    string,
+    { sessionId: string; colour: string | null }
+  > = new Map();
   // Most recent terminal per project, tagged with the conversation it runs so
   // reuse can tell a project's branches apart.
   private readonly _byProject: Map<

package/src/index.ts

@@ -250,9 +250,9 @@ const plugin: JupyterFrontEndPlugin<void> = {
           descriptor: module.descriptor,
           hooks: module.hooks,
           rootDir: status?.root_dir ?? '',
-          // Unknown reads as "not trash": the popup then arms its Delete
-          // button before it executes, which is the only confirmation a
-          // permanent bulk delete has (DEF-135).
+          // Unknown reads as "not trash", so the dialogs and the popup
+          // present the permanent-delete wording rather than promising a
+          // recoverable move the server never confirmed (DEF-135).
           deleteToTrash: status ? status.delete_to_trash !== false : false,
           terminalTracker,
           fileBrowser,

package/style/base.css

@@ -562,7 +562,9 @@ body[data-jp-theme-light='true'] .jp-AiAssistantsPanel-dotHalo {
 
   /* 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. */
+     1.74:1 on the light panel, below the 3:1 minimum for a non-text cue. Held
+     still it would read as idle, so the overlay names the action in a visible
+     label beside it; the label, not an animation, carries the busy state. */
   .jp-AiAssistants-busySpinner {
     opacity: 1;
   }
@@ -601,6 +603,7 @@ body[data-jp-theme-light='true'] .jp-AiAssistantsPanel-dotHalo {
   display: flex;
   align-items: center;
   justify-content: center;
+  gap: 12px;
   pointer-events: none;
 }
 
@@ -610,6 +613,15 @@ body[data-jp-theme-light='true'] .jp-AiAssistantsPanel-dotHalo {
   border-width: 3px;
 }
 
+.jp-AiAssistants-busyLabel {
+  color: var(--jp-ui-font-color1);
+  background: var(--jp-layout-color1);
+  border: 1px solid var(--jp-border-color2);
+  border-radius: 4px;
+  padding: 4px 10px;
+  font-size: var(--jp-ui-font-size1);
+}
+
 .jp-AiAssistantsPanel-launchOverlay {
   display: flex;
   flex-direction: column;