jupyterlab_ai_code_assistants_extension 1.2.115 → 1.2.120

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

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/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/package.json

@@ -1,6 +1,6 @@
 {
     "name": "jupyterlab_ai_code_assistants_extension",
-    "version": "1.2.115",
+    "version": "1.2.120",
     "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__/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/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/style/base.css

@@ -550,26 +550,6 @@ body[data-jp-theme-light='true'] .jp-AiAssistantsPanel-dotHalo {
   order: -1;
 }
 
-/* The spin carries "busy", not information, so under a reduced-motion
-   preference it degrades to the same ring held still and dimmed. */
-@media (prefers-reduced-motion: reduce) {
-  .jp-AiAssistantsPanel-iconButton.jp-mod-spinning svg,
-  .jp-aiAssistants-spinner,
-  .jp-AiAssistantsPanel-spinner {
-    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. 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;
-  }
-}
-
 /* Full-panel veil shown only during an explicit refresh (refresh button or
    panel show) - the background poll never raises it. The rule is gated on
    :not([hidden]) because this author `display` would otherwise beat the UA