jupyterlab_ai_code_assistants_extension 1.1.13 → 1.2.4

package/lib/core/terminals.js

@@ -1,12 +1,50 @@
-import { Dialog } from '@jupyterlab/apputils';
+import { Dialog, Notification } from '@jupyterlab/apputils';
 import { Widget } from '@lumino/widgets';
-import { effectiveColour, readUserSetTabColour, sessionForCwds } from './colour';
+import { effectiveColour, sessionForCwds } from './colour';
 import { LOG_PREFIX } from './registry';
 import { requestProvider } from './request';
 /** Colour reconciliation cadence. Matches the row poll so the two collapse
  * into one rhythm while the panel is visible, but it is a separate timer: a
  * terminal running the assistant is tinted whether or not the panel is open. */
 const COLOUR_INTERVAL_MS = 30000;
+/** Narrow the injected colour token to the ownership API, or null.
+ *
+ * A run-time probe rather than a type test, because the typings this
+ * repository compiles against are the published ones and carry `setColour`
+ * alone - see `ITabColourEvents`.
+ */
+function tabColourOwner(tabs) {
+    var _a;
+    const candidate = tabs;
+    if (typeof (candidate === null || candidate === void 0 ? void 0 : candidate.claim) !== 'function' ||
+        typeof ((_a = candidate.colourChanged) === null || _a === void 0 ? void 0 : _a.connect) !== 'function') {
+        return null;
+    }
+    return candidate;
+}
+/** Said once per page, not once per provider: every assistant panel builds a
+ * manager against the same companion, so the latch is what keeps one missing
+ * upgrade from printing the same line four times. */
+let warnedLegacyCompanion = false;
+/** An installed companion too old to carry the ownership API. Loud because the
+ * consequence is visible: this extension tints nothing at all against one, so
+ * a user whose assistant tabs used to be coloured watches them go plain, and
+ * the cause is one upgrade away. */
+function warnLegacyCompanion() {
+    if (warnedLegacyCompanion) {
+        return;
+    }
+    warnedLegacyCompanion = true;
+    const message = `jupyterlab_colourful_tab_extension is older than the release that reports tab colour choices and lets another extension own a tab. Terminal tab tinting is off until that extension is upgraded; its own right-click colours keep working as they always did.`;
+    console.warn(`${LOG_PREFIX} ${message}`);
+    // And said where the user is looking. The symptom is tabs that are simply
+    // plain, which reads as a feature that was never on rather than as something
+    // to fix, and a console line only reaches someone already suspecting the
+    // cause. The two neighbouring "an installed thing is wrong" announcements in
+    // this extension both pair the console line with this toast. It does not
+    // close on its own, because the condition does not go away on its own.
+    Notification.warning(message, { autoClose: false });
+}
 /** Show a modal spinner while a terminal is being launched. The caller
  * dismisses it with `.dispose()` when the launch settles.
  *
@@ -46,6 +84,18 @@ export function showLaunchSpinner(title) {
  */
 export class TerminalManager {
     constructor(options) {
+        // One claim per terminal, keyed by widget id - see `_claimTab` for why that
+        // id identifies exactly one widget.
+        this._claims = new Map();
+        // Choices made on a terminal that probed as this provider's while its
+        // conversation was not yet readable, keyed by the same widget id and holding
+        // the colour id chosen (null for a clear). A probe that FAILED records
+        // nothing - it says nothing about whose terminal it is, and a choice held on
+        // that basis lands on a conversation the user never coloured. The signal
+        // fires once, so this map is the only thing keeping such a pick alive until a
+        // 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();
         // Most recent terminal per project, tagged with the conversation it runs so
         // reuse can tell a project's branches apart.
         this._byProject = new Map();
@@ -55,17 +105,43 @@ export class TerminalManager {
         this._sessions = [];
         this._colouredTabs = true;
         this._colourHandle = null;
+        // Order of the colour passes, `reconcileColours` and `clearColours` alike.
+        // A pass whose generation is no longer the current one has been overtaken and
+        // neither sweeps nor paints - a counter, not a timer.
+        this._pass = 0;
         this._disposed = false;
         this._app = options.app;
         this._descriptor = options.descriptor;
         this._colours = options.colourStore;
         this._tracker = options.terminalTracker;
-        this._colourfulTabs = options.colourfulTabs;
         this._serverSettings = options.serverSettings;
+        // This narrowing decides whether the extension tints at all. Against a
+        // companion with no ownership API it paints nothing: a colour the user
+        // picks on a tab cannot be captured there, so the next pass would repaint
+        // the conversation's effective colour straight over the pick. Leaving the
+        // tabs alone is what makes the companion's own menu behave exactly as it
+        // did before this extension was installed.
+        this._tabs = tabColourOwner(options.colourfulTabs);
+        if (this._tabs) {
+            // Subscribed here rather than when the panel is first shown: a colour
+            // picked on a tab has to be captured whether or not the user ever opens
+            // this assistant's panel, and every panel is constructed at activation.
+            this._tabs.colourChanged.connect(this._onColourChanged, this);
+        }
+        else if (options.colourfulTabs) {
+            warnLegacyCompanion();
+        }
     }
     dispose() {
+        var _a;
         this._disposed = true;
         this.stopColourLoop();
+        (_a = this._tabs) === null || _a === void 0 ? void 0 : _a.colourChanged.disconnect(this._onColourChanged, this);
+        this._releaseClaims();
+        // A choice waiting for a conversation belongs to a panel that is still
+        // 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();
     }
     /**
      * Open a conversation, reusing an open terminal only when that terminal is
@@ -250,74 +326,92 @@ export class TerminalManager {
      *
      * Each terminal's conversation is re-resolved on every pass rather than
      * taken from the launch cache, which pins the launch-time conversation and
-     * goes stale on an in-place switch. On the way through, a colour the user
-     * set by hand on the tab is written back into this provider's colour store,
-     * which is what makes "set the tab colour" mean "this conversation's colour"
-     * even for an assistant whose CLI has no colour concept.
+     * goes stale on an in-place switch.
+     *
+     * It touches this extension's own store and nothing else - no browser
+     * storage, no other extension's records, and that must stay true. The colour
+     * the user picks on a tab arrives as a signal instead (`_onColourChanged`);
+     * reading it back out of the companion's storage is what made a recycled
+     * terminal name hand a dead terminal's colour to a live conversation,
+     * permanently, at the top of the ladder. The only write this pass makes is a
+     * choice that signal already delivered, whose conversation was unreadable at
+     * the time - see `_pendingChoices`.
      */
     async reconcileColours() {
         if (!this._colouredTabs) {
             // No rearm: `setColouredTabs(true)` calls straight back in here.
             return;
         }
+        // This pass's place in the order. A pass awaiting a probe can be overtaken
+        // by a later one, and only the pass that is still current may sweep or
+        // paint: an overtaken pass would release a claim the newer one legitimately
+        // took, and repaint over what it drew.
+        const generation = ++this._pass;
         try {
+            // Ids recognised as this assistant's on THIS pass. Every other claim is
+            // released at the end of it - see `_releaseLapsedClaims`.
+            const recognised = new Set();
+            // Ids the server positively answered are NOT this assistant's on this
+            // pass. Separate from "not in `recognised`", which also holds for a
+            // terminal whose probe simply failed.
+            const disowned = new Set();
             await this._eachAssistantTerminal(async (widget, info) => {
-                var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
-                const sessionId = (_d = (_a = info.session_id) !== null && _a !== void 0 ? _a : (_c = sessionForCwds((_b = info.cwds) !== null && _b !== void 0 ? _b : [], this._sessions)) === null || _c === void 0 ? void 0 : _c.session_id) !== null && _d !== void 0 ? _d : null;
-                const terminalName = (_g = (_f = (_e = widget === null || widget === void 0 ? void 0 : widget.content) === null || _e === void 0 ? void 0 : _e.session) === null || _f === void 0 ? void 0 : _f.name) !== null && _g !== void 0 ? _g : '';
-                // Write-back. The tab is the control surface for EVERY assistant,
-                // native-colour ones included: setting a colour there diverges from
-                // whatever the CLI's own colour said, and that later choice is the one
-                // remembered from here on.
-                //
-                // Keyed on the OBSERVED conversation only. `sessionId` above may be the
-                // project's representative conversation resolved from a cwd, which is
-                // good enough to paint with but not to write against: filing the user's
-                // colour under a guessed id recolours a conversation they never touched.
-                const userSet = terminalName
-                    ? readUserSetTabColour(terminalName)
-                    : null;
-                if (userSet) {
-                    const observedId = (_h = info.session_id) !== null && _h !== void 0 ? _h : null;
-                    // Held by the store already (an earlier pass captured it), or
-                    // captured right now with the write confirmed by the server.
-                    // Held AS THE USER'S OWN. Matching the colour alone is not enough: a
-                    // branch born wearing this tint holds it as inherited, so re-picking
-                    // the same colour on that tab would be swallowed and the choice
-                    // would never become releasable. The cache carries only values the
-                    // server confirmed, so reading it is the confirmation - which is why
-                    // it is never written ahead of the answer.
-                    let held = !!observedId &&
-                        this._colours.get(observedId) === userSet &&
-                        this._colours.isOverride(observedId);
-                    if (observedId && !held) {
-                        // Strip OUR tint from `title.className` first. The companion
-                        // extension's menu writes its own storage and the tab ELEMENT's
-                        // classes, never the title - and Lumino rebuilds that element's
-                        // class attribute from the title whenever the current tab changes,
-                        // so a tint of ours still sitting there comes back over the colour
-                        // the user just picked. With the title bare, the companion's own
-                        // refresh holds their choice until this write confirms.
-                        this._applyColour(widget, null);
-                        held = await this._colours.set(observedId, userSet);
+                var _a, _b, _c, _d, _e, _f, _g, _h;
+                if (!this._colouredTabs ||
+                    this._disposed ||
+                    this._pass !== generation) {
+                    // `clearColours()`, `dispose()` or a NEWER pass landed while this one
+                    // was in flight. The first two release every claim and are done by
+                    // the time this runs, so claiming or painting now would put back
+                    // exactly what they took away, with nothing left to undo it; the
+                    // third owns these tabs from here on.
+                    return;
+                }
+                // Recognition is what earns the claim, so it is taken here rather than
+                // at launch: a terminal the user started by hand is this assistant's
+                // too, and only the probe can say so.
+                recognised.add(widget.id);
+                this._claimTab(widget);
+                if (this._pendingChoices.has(widget.id)) {
+                    // The conversation the running PROCESS holds, never the folder
+                    // fallback below: a project holds many conversations, and filing the
+                    // user's colour under the wrong one recolours a conversation they
+                    // never touched.
+                    if (!info.session_id) {
+                        // Still unreadable, so the choice cannot be filed yet - and this
+                        // tab must not be painted either. Every colour available to paint
+                        // is the conversation's previous one, which is what the pick was
+                        // meant to replace, and the pending record is what says the pick
+                        // has not been honoured.
+                        return;
                     }
-                    if (!held) {
-                        // Nothing remembers this colour yet, so painting one would destroy
-                        // it: any colour applied makes the colourful-tab extension release
-                        // its menu entry. Strip OUR tint instead and stop - Lumino rebuilds
-                        // the tab's classes from `title.className`, so a tint left there by
-                        // an earlier pass would otherwise keep showing in place of the
-                        // colour the user just picked, and the companion repaints its own
-                        // once the class is gone. The next pass retries the capture.
-                        this._applyColour(widget, null);
+                    const choice = (_a = this._pendingChoices.get(widget.id)) !== null && _a !== void 0 ? _a : null;
+                    // Dropped on the attempt, not on success. A refused write is the
+                    // store being unwritable rather than the conversation being
+                    // unreadable, and retrying it on every pass would warn every 30
+                    // seconds for the rest of the session.
+                    this._pendingChoices.delete(widget.id);
+                    const filed = await this._fileChoice(info.session_id, choice);
+                    if (!filed ||
+                        !this._colouredTabs ||
+                        this._disposed ||
+                        this._pass !== generation) {
                         return;
                     }
                 }
-                const native = (_j = info.colour) !== null && _j !== void 0 ? _j : (sessionId
-                    ? ((_l = (_k = this._sessions.find(s => s.session_id === sessionId)) === null || _k === void 0 ? void 0 : _k.colour) !== null && _l !== void 0 ? _l : null)
+                const sessionId = (_e = (_b = info.session_id) !== null && _b !== void 0 ? _b : (_d = sessionForCwds((_c = info.cwds) !== null && _c !== void 0 ? _c : [], this._sessions)) === null || _d === void 0 ? void 0 : _d.session_id) !== null && _e !== void 0 ? _e : null;
+                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));
-            });
+            }, widget => disowned.add(widget.id));
+            if (this._pass === generation) {
+                // Skipped by an overtaken pass: its view of what is recognised and what
+                // is open is the older one, and acting on it would undo the newer
+                // pass's work.
+                this._releaseLapsedClaims(recognised);
+                this._dropStalePending(disowned);
+            }
         }
         catch (err) {
             // Tinting reaches into another extension and a probe per terminal, so
@@ -354,8 +448,24 @@ export class TerminalManager {
      * another extension, both are called as `void`, and turning tab colouring
      * off must not spill an unhandled rejection. */
     async clearColours() {
+        // Ownership goes with the tint. With colouring off `_captureColour` files
+        // nothing, so a claim held here would leave a colour picked on that tab
+        // persisted by nobody.
+        this._releaseClaims();
+        // And so does a choice still waiting for its conversation. Filing it later
+        // would put a colour on the top rung of a ladder this extension is not
+        // drawing, which is the same thing `_captureColour` refuses to do while
+        // colouring is off.
+        this._pendingChoices.clear();
+        const generation = ++this._pass;
         try {
             await this._eachAssistantTerminal(async (widget) => {
+                if (this._pass !== generation) {
+                    // A `setColouredTabs(true)` overtook this clear and has already
+                    // painted. Stripping now would take that tint straight off again,
+                    // and nothing would put it back until the next pass.
+                    return;
+                }
                 this._applyColour(widget, null);
             });
         }
@@ -363,20 +473,239 @@ export class TerminalManager {
             // Nothing to retry - the setting is off either way.
         }
     }
+    /** The user picked a colour on a tab, or cleared one.
+     *
+     * The slot itself stays synchronous - Lumino ignores what a slot returns, so
+     * an async slot's rejection would surface as an unhandled one.
+     */
+    _onColourChanged(_sender, choice) {
+        void this._captureColour(choice);
+    }
+    /** File one choice against the conversation the coloured terminal is
+     * actually running.
+     *
+     * Only a terminal this provider owns, and only one whose conversation the
+     * server READ from the running process. A widget whose conversation cannot
+     * be read is never filed against one guessed from its folder: a project has
+     * many conversations, and filing the user's colour under the wrong one
+     * recolours a conversation they never touched. That choice waits instead,
+     * but only where the probe named the terminal - see `_pendingChoices`.
+     */
+    async _captureColour(choice) {
+        if (!this._colouredTabs) {
+            // Nothing here is claimed while colouring is off, so the companion owns
+            // that tab and keeps the choice itself. Taking a copy would put a colour
+            // on the top rung of a ladder this extension is not drawing, to surface
+            // the day the setting is turned back on.
+            return;
+        }
+        try {
+            const widget = this._liveTerminals().find(w => w.id === choice.widgetId);
+            if (!widget) {
+                return;
+            }
+            const info = await this.probe(widget);
+            if (!this._colouredTabs || this._disposed) {
+                // Switched off, or the panel disposed, while the probe was in flight.
+                // The check on entry cannot cover this: what is written from here is
+                // hand-set, the top rung of a ladder that is no longer being drawn, and
+                // it would surface the day the setting is turned back on.
+                return;
+            }
+            if (!info || !info.running) {
+                // Not this assistant's terminal, or a probe that could not be read at
+                // all. Neither is evidence of ownership, so neither is remembered: a
+                // failed probe says only that the server did not answer, and a choice
+                // held on that basis is filed against whatever conversation the
+                // terminal later turns out to run.
+                if (!info) {
+                    // Said, not swallowed. The companion has already deleted whatever it
+                    // held for this tab and persisted nothing new, so on a probe that did
+                    // not answer the pick now exists only as a class Lumino rebuilds away
+                    // at the next tab switch - the user watches their colour appear and
+                    // then vanish. Every other losing path in this file speaks; this one
+                    // is the same kind of loss.
+                    console.warn(`${LOG_PREFIX}[${this._descriptor.id}] tab colour could not be attributed to a conversation - the terminal probe did not answer, so the choice was not kept.`);
+                }
+                else {
+                    // The server ANSWERED, and the answer is that this terminal is no
+                    // longer running this assistant. That ends the conversation any held
+                    // choice was picked under, so the hold is released here rather than a
+                    // pass later: the assistant coming back in this same terminal starts a
+                    // NEW conversation, and the widget id does not change, so a choice
+                    // that survives the gap is filed as hand-set against a conversation
+                    // the user picked no colour for. `_dropStalePending` already acts on
+                    // exactly this evidence - this is the same rule at the moment the
+                    // evidence arrives.
+                    this._pendingChoices.delete(choice.widgetId);
+                }
+                return;
+            }
+            if (!info.session_id) {
+                // The terminal IS this assistant's - the probe said so - and its
+                // conversation is not readable yet: the CLI has not written it. The
+                // signal fires ONCE, so dropping the choice here loses it, and the next
+                // pass then paints the conversation's effective colour straight over
+                // the pick. Remembered instead and re-attempted by that same pass,
+                // which probes every terminal anyway. Keyed by widget id, so a later
+                // choice on this tab replaces this one - the user changing their mind.
+                this._pendingChoices.set(choice.widgetId, choice.colourId);
+                // And paint the PICK, which nothing else now holds. The companion has
+                // deleted whatever it stored for this claimed tab, and the store has not
+                // got the choice yet, so without this the colour lives only as a class
+                // on the tab element that Lumino rebuilds away at the next tab switch -
+                // the user's colour appears, vanishes, and returns by itself when the
+                // pass finally files it. Painting here writes the widget's Lumino title
+                // instead, which rides re-renders. This is not the ladder being painted
+                // over the pick, which the pass below still refuses to do: it is the
+                // pick itself, and it is the only colour that is correct to show.
+                this._applyColour(widget, choice.colourId);
+                return;
+            }
+            // An earlier pick on this same tab, held because its conversation was
+            // unreadable then, is superseded the moment a newer one can be filed.
+            // Dropped BEFORE the write, not after it: the reconcile two lines below
+            // replays whatever is still pending, so a choice left here is filed
+            // straight back over the one about to be written - the user's older pick
+            // replacing their newer one, which is this design's own defect one layer
+            // up. Dropped on a refused write too, for the same reason: the pick that
+            // superseded it was made either way.
+            this._pendingChoices.delete(choice.widgetId);
+            if (!(await this._fileChoice(info.session_id, choice.colourId))) {
+                return;
+            }
+            await this.reconcileColours();
+        }
+        catch (err) {
+            console.warn(`${LOG_PREFIX}[${this._descriptor.id}] tab colour capture failed.`, err);
+        }
+    }
+    /** Write one choice into this extension's own store - a colour for a pick, a
+     * forget for a clear - and answer whether the store now holds it.
+     *
+     * Nothing is painted for a refused write, at either call site. The tab is
+     * claimed, so the companion holds no record of this choice and there is
+     * nothing in the store either - every colour this extension could paint is
+     * the conversation's PREVIOUS one, which is what the pick was meant to
+     * replace. What the user sees instead is the class the companion's menu put
+     * on the tab element, and that survives only until the next tab switch:
+     * Lumino rebuilds a tab's class attribute from the widget title whenever the
+     * current tab changes, and the title still carries that previous colour. So
+     * the choice is lost either way - the warning is what makes it something
+     * other than silent. */
+    async _fileChoice(sessionId, colourId) {
+        const stored = colourId
+            ? await this._colours.set(sessionId, colourId)
+            : await this._colours.forget([sessionId]);
+        if (!stored) {
+            console.warn(`${LOG_PREFIX}[${this._descriptor.id}] tab colour choice was not stored; the conversation keeps its previous colour.`);
+        }
+        return stored;
+    }
+    /** Tell the companion this tab's colour is ours to persist.
+     *
+     * Once per terminal, not once per pass - the pass runs every 30 seconds and
+     * each claim is a disposable the companion has to hold. A widget id is a
+     * safe key for that: JupyterLab mints one uuid per widget (`id-<uuid4>`,
+     * verified against 4.6.3 on 2026-09-04) and never hands it to a second
+     * widget, so a claim held under an id belongs to the widget still wearing
+     * it. Terminal NAMES are what terminado recycles - which is why the
+     * companion fingerprints what it persists, and why nothing here keys on a
+     * name.
+     */
+    _claimTab(widget) {
+        const tabs = this._tabs;
+        const id = widget === null || widget === void 0 ? void 0 : widget.id;
+        if (!tabs || !id || this._claims.has(id)) {
+            return;
+        }
+        this._claims.set(id, tabs.claim(widget));
+    }
+    /** Give up every claim this pass did not renew.
+     *
+     * A claim says "this extension draws this tab and records what you pick on
+     * it", and that stops being true the moment the terminal stops probing as
+     * this assistant's - it exited, another assistant took the pty, or the
+     * widget is gone from the tracker altogether. Holding on would leave a
+     * colour picked on that tab persisted by nobody, and the map growing by one
+     * entry per closed terminal for the life of the page.
+     *
+     * A terminal whose probe merely failed is released too, since an unreadable
+     * terminal is not evidence of ownership. The next pass that reads it claims
+     * it again, and re-claiming costs nothing visible: a claim suppresses the
+     * companion's persistence and narrows its repaint to a fingerprint-verified
+     * entry, deleting nothing it stored before, and the next paint puts this
+     * conversation's colour back. */
+    _releaseLapsedClaims(recognised) {
+        this._claims.forEach((claim, id) => {
+            if (!recognised.has(id)) {
+                claim.dispose();
+                this._claims.delete(id);
+            }
+        });
+    }
+    _releaseClaims() {
+        this._claims.forEach(claim => claim.dispose());
+        this._claims.clear();
+    }
+    /** Forget the choices whose premise no longer holds.
+     *
+     * A choice is held on one answer only - this assistant's terminal, its
+     * conversation not readable yet - and it stops being a choice about anything
+     * the moment either half of that stops being true.
+     *
+     * The terminal CLOSED. A pending choice is about one tab and must not outlive
+     * it. A widget id is never handed to a second widget, so the record could
+     * never be filed again - what it would do is hold that widget's id, one entry
+     * per closed terminal, for the life of the page.
+     *
+     * The terminal is no longer THIS ASSISTANT'S, per an answer the server
+     * actually gave. The conversation the pick was made under has ended, and the
+     * assistant coming back in the same terminal starts a NEW one - so a choice
+     * kept across that gap is filed against a conversation the user never picked
+     * a colour for, as hand-set, at the top of the ladder. A probe that failed is
+     * deliberately not evidence here: it says only that the server did not
+     * answer, and discarding the pick on that basis loses a colour the user chose
+     * seconds ago. */
+    _dropStalePending(disowned) {
+        if (this._pendingChoices.size === 0) {
+            return;
+        }
+        const open = new Set(this._liveTerminals().map(widget => widget.id));
+        this._pendingChoices.forEach((_choice, id) => {
+            if (!open.has(id) || disowned.has(id)) {
+                this._pendingChoices.delete(id);
+            }
+        });
+    }
     _applyColour(widget, colourId) {
-        if (!this._colourfulTabs || !widget || widget.isDisposed) {
+        if (!this._tabs || !widget || widget.isDisposed) {
             return;
         }
-        this._colourfulTabs.setColour(widget, colourId);
+        this._tabs.setColour(widget, colourId);
     }
-    async _eachAssistantTerminal(apply) {
-        if (!this._colourfulTabs || !this._tracker) {
+    async _eachAssistantTerminal(apply, disowned) {
+        // No ownership API, no tinting - see the constructor. The guard sits here
+        // so that every path through the tint (the pass, the clear, the capture's
+        // repaint) stops at the same place.
+        if (!this._tabs || !this._tracker) {
             return;
         }
         const widgets = this._liveTerminals();
         await Promise.all(widgets.map(async (widget) => {
             const info = await this.probe(widget);
-            if (!info || !info.running || widget.isDisposed) {
+            if (widget.isDisposed || !info) {
+                // A probe that did not answer says nothing about whose terminal this
+                // is, so nothing is concluded from it - neither by the caller's
+                // `apply` nor by its `disowned`.
+                return;
+            }
+            if (!info.running) {
+                // The server answered, and the answer is that this assistant is not
+                // what the terminal runs. That is the positive evidence `disowned`
+                // exists for, and it is why the two cases above cannot share this
+                // branch.
+                disowned === null || disowned === void 0 ? void 0 : disowned(widget);
                 return;
             }
             await apply(widget, info);

package/lib/core/types.d.ts

@@ -246,6 +246,37 @@ export interface IColourStoreResponse {
      * list, since its two origins are indistinguishable there. */
     overrides?: string[];
 }
+/** One colour choice made on a tab, as `jupyterlab_colourful_tab_extension`
+ * reports it: the widget whose tab was coloured, and the colour id chosen -
+ * null when the user cleared the colour. The id is the colour's NAME rather
+ * than an index into a palette, so the companion can reorder or rename its
+ * six colours without silently repainting every captured conversation. */
+export interface IColourChoice {
+    widgetId: string;
+    colourId: string | null;
+}
+/** The two members `jupyterlab_colourful_tab_extension` grew so that another
+ * extension can own a tab's colour: the signal that reports a choice, and the
+ * claim that stops the companion persisting a tab another extension owns.
+ *
+ * Declared structurally here instead of being read off the imported
+ * `IColourfulTabs`, because this repository compiles against the PUBLISHED
+ * companion typings, which carry `setColour` alone. Typing the members as
+ * optional and probing for them at run time is the one shape that both builds
+ * against those typings and degrades honestly against an older companion at
+ * run time. Honestly means all the way: where the probe fails this extension
+ * leaves tabs alone rather than painting ones whose colours it could never be
+ * told about. Both members ship in the same companion release, so one probe
+ * answers for the pair. */
+export interface ITabColourEvents {
+    colourChanged?: {
+        connect(slot: (sender: unknown, choice: IColourChoice) => void, thisArg?: unknown): boolean;
+        disconnect(slot: (sender: unknown, choice: IColourChoice) => void, thisArg?: unknown): boolean;
+    };
+    claim?: (widget: unknown) => {
+        dispose(): void;
+    };
+}
 /** Optional behaviour a provider module supplies on top of its descriptor.
  * Every hook is optional - a provider that supplies none renders the plain
  * shared panel. */

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "jupyterlab_ai_code_assistants_extension",
-    "version": "1.1.13",
+    "version": "1.2.4",
     "description": "Jupyterlab extension to replace individual jupyterlab_*_code_extension and integrate into one, that offers joint capability, joint settings page and individual right toolbar panels per code assistant, with the ability in settings to decide which code assistant support is on (default - all are enabled)",
     "keywords": [
         "jupyter",