jupyterlab_claude_code_extension 1.2.41 → 1.2.43

package/README.md

@@ -36,6 +36,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 (normal or skip-permissions mode); uses Claude's native `--fork-session`, opens in a new terminal, the chosen name is stamped automatically, and the fork becomes the row's current conversation
 - **Copy session id** - a right-click "Copy Session ID" item copies the row's current conversation id to the clipboard; the Manage Sessions popup adds a copy button on every row, so any parallel conversation's id is one click away
 - **Activity at a glance** - each row shows its last activity (`now`, `5m ago`, `2h ago`, `3d ago`) in an aligned column, with the favourite star in its own column beside it; rows active within the last minute light up in the theme's brand colour (including the `now` label), rows idle for over a week dim slightly
+- **Coloured terminal tabs** - each Claude session's colour (set with `/color`, or auto-assigned) tints its terminal tab, so open sessions are easy to tell apart; needs the companion `jupyterlab_colourful_tab_extension` (>= 1.0.19), which supplies the tab-colouring API
 - **Search** - fuzzy filter toggled by the funnel button next to refresh
 - **Presentation modes** - label rows by session name (so a `/rename` shows through), folder name, or path relative to the JupyterLab root
 - **Hover tooltip** with project path, last activity, message count, branch, and session id

package/lib/index.js

@@ -2,6 +2,7 @@ import { ILabShell, ILayoutRestorer } from '@jupyterlab/application';
 import { IDefaultFileBrowser } from '@jupyterlab/filebrowser';
 import { ISettingRegistry } from '@jupyterlab/settingregistry';
 import { ITerminalTracker } from '@jupyterlab/terminal';
+import { IColourfulTabs } from 'jupyterlab_colourful_tab_extension';
 import { requestAPI } from './request';
 import { ClaudeCodeSessionsWidget } from './widget';
 const PLUGIN_ID = 'jupyterlab_claude_code_extension:plugin';
@@ -15,9 +16,10 @@ const plugin = {
         ILayoutRestorer,
         ISettingRegistry,
         ITerminalTracker,
-        IDefaultFileBrowser
+        IDefaultFileBrowser,
+        IColourfulTabs
     ],
-    activate: async (app, labShell, restorer, settingRegistry, terminalTracker, fileBrowser) => {
+    activate: async (app, labShell, restorer, settingRegistry, terminalTracker, fileBrowser, colourfulTabs) => {
         const settings = app.serviceManager.serverSettings;
         let status;
         try {
@@ -31,7 +33,7 @@ const plugin = {
             console.info('[jupyterlab_claude_code_extension] `claude` binary not found on PATH; panel disabled.');
             return;
         }
-        const widget = new ClaudeCodeSessionsWidget(app, status.root_dir || '', terminalTracker, fileBrowser);
+        const widget = new ClaudeCodeSessionsWidget(app, status.root_dir || '', terminalTracker, fileBrowser, colourfulTabs);
         // Read the sidebar setting before docking so we add the widget to the
         // user's preferred side on first paint. Default to right.
         let currentSidebar = 'right';

package/lib/types.d.ts

@@ -14,6 +14,9 @@ export interface ISession {
     remote_control: boolean;
     favourite: boolean;
     extra_sessions: number;
+    /** Claude session colour from `/color` or auto-assignment (e.g. "blue"), or
+     * null when the session carries none. Drives the terminal tab tint. */
+    color: string | null;
 }
 export interface ISessionsListResponse {
     sessions: ISession[];

package/lib/widget.d.ts

@@ -1,11 +1,12 @@
 import { JupyterFrontEnd } from '@jupyterlab/application';
 import { IDefaultFileBrowser } from '@jupyterlab/filebrowser';
 import { ITerminalTracker } from '@jupyterlab/terminal';
+import { IColourfulTabs } from 'jupyterlab_colourful_tab_extension';
 import { Widget } from '@lumino/widgets';
 import { Message } from '@lumino/messaging';
 export type PresentationMode = 'name' | 'path';
 export declare class ClaudeCodeSessionsWidget extends Widget {
-    constructor(app: JupyterFrontEnd, rootDir: string, terminalTracker?: ITerminalTracker | null, fileBrowser?: IDefaultFileBrowser | null);
+    constructor(app: JupyterFrontEnd, rootDir: string, terminalTracker?: ITerminalTracker | null, fileBrowser?: IDefaultFileBrowser | null, colourfulTabs?: IColourfulTabs | null);
     refresh(): void;
     /** Choose how rows are labelled: by name (session name, initially the
      * folder name), or by path. */
@@ -81,6 +82,38 @@ export declare class ClaudeCodeSessionsWidget extends Widget {
      * first.
      */
     private _focusTerminal;
+    /** Tint a terminal's dock tab with the colour of the Claude session it runs,
+     * delegating to jupyterlab_colourful_tab_extension's `setColour` API so that
+     * extension owns the tab CSS and colour vocabulary. A no-op when the
+     * colourful-tab extension is not installed (the token is optional). An
+     * absent/unknown colour clears the tint. */
+    private _applyTerminalColour;
+    /** Re-tint EVERY open Claude terminal tab from the freshest session colours,
+     * whether the plugin launched it or the user opened it themselves. Walks
+     * JupyterLab's terminal tracker (the registry of all open terminals) rather
+     * than only the plugin's own launch cache, and re-resolves each terminal's
+     * Claude conversation on every pass via the ``terminal-cwd`` probe - so a tab
+     * whose terminal has since started (or switched) a Claude conversation is
+     * re-tinted correctly rather than pinned to a stale identity. The probe is a
+     * few /proc reads per terminal; runs after each fetch (launch refresh + the
+     * 30s poll), which is already gated to skip while a context menu is open. */
+    private _reconcileTerminalColours;
+    /** Resolve a terminal's Claude identity: does it run Claude, which
+     * conversation id, and its cwd(s). Panel-launched terminals are already known
+     * (their conversation was confirmed at launch), so those skip the backend
+     * probe; every other terminal is probed once via ``terminal-cwd``. Returns
+     * ``null`` when the terminal has no session name yet or the probe fails. */
+    private _interrogateTerminal;
+    /** Pick a terminal's tab colour from the session list. When the terminal runs
+     * a known conversation (its argv carried a ``--resume`` / ``--session-id``),
+     * match on that id ONLY: it takes the colour of the exact conversation, or -
+     * when that conversation is not the project's representative row - clears,
+     * rather than borrowing a sibling branch's colour. The cwd fallback is used
+     * ONLY for a terminal with no conversation id (a bare ``claude`` / ``-c``),
+     * matching the project the terminal is cwd'd in and preferring the longest
+     * matching path so a nested project wins over its parent. Returns null (clear)
+     * when no row matches or the matched row has no colour. */
+    private _colourForTerminal;
     private _findTerminalForCwd;
     private _showCloseExistingDialog;
     /** Show a modal with a spinner while the terminal is being launched. The
@@ -204,6 +237,7 @@ export declare class ClaudeCodeSessionsWidget extends Widget {
     private readonly _removingPaths;
     private readonly _terminalTracker;
     private readonly _fileBrowser;
+    private readonly _colourfulTabs;
     private readonly _terminalsByPath;
     private readonly _pendingByPath;
     private readonly _rootDir;

package/lib/widget.js

@@ -14,6 +14,21 @@ const BRANCH_WATCH_MAX_ATTEMPTS = 90; // ~3 minutes
 const DEFAULT_RECENT_LIMIT = 10;
 const EXPANDED_STORAGE_KEY = 'jupyterlab_claude_code_extension:expanded';
 const DEFAULT_PRESENTATION_MODE = 'name';
+// Claude's per-session colour (set by `/color`, or auto-assigned for
+// multi-session use) maps to a jupyterlab_colourful_tab_extension colour id.
+// That extension owns the tab-tint CSS and the setColour API; we only feed it
+// the colour. An absent or unrecognised colour resolves to null (clear tint).
+const CLAUDE_TAB_COLOUR_ID = {
+    red: 'rose',
+    orange: 'peach',
+    yellow: 'lemon',
+    green: 'mint',
+    blue: 'sky',
+    purple: 'lavender'
+};
+function claudeTabColourId(color) {
+    return (color && CLAUDE_TAB_COLOUR_ID[color]) || null;
+}
 const SECTION_LABELS = {
     favourites: 'Favorites',
     recent: 'Recent',
@@ -62,7 +77,7 @@ catch (_err) {
     // ignore
 }
 export class ClaudeCodeSessionsWidget extends Widget {
-    constructor(app, rootDir, terminalTracker = null, fileBrowser = null) {
+    constructor(app, rootDir, terminalTracker = null, fileBrowser = null, colourfulTabs = null) {
         super();
         this._loadingEl = null;
         this._refreshBtn = null;
@@ -92,6 +107,7 @@ export class ClaudeCodeSessionsWidget extends Widget {
         this._rootDir = rootDir.replace(/\/+$/, '');
         this._terminalTracker = terminalTracker;
         this._fileBrowser = fileBrowser;
+        this._colourfulTabs = colourfulTabs;
         this.id = 'jupyterlab-claude-code-extension';
         this.title.icon = claudeIcon;
         this.title.caption = 'Claude Code Sessions';
@@ -337,6 +353,8 @@ export class ClaudeCodeSessionsWidget extends Widget {
         const data = await requestAPI('sessions', this._serverSettings, { cache: 'no-store' });
         this._sessions = (_a = data.sessions) !== null && _a !== void 0 ? _a : [];
         this._render();
+        // Best-effort tab tinting; never let a colour failure break the fetch.
+        this._reconcileTerminalColours().catch(() => undefined);
     }
     async _toggleFavourite(session) {
         const next = !session.favourite;
@@ -641,6 +659,105 @@ export class ClaudeCodeSessionsWidget extends Widget {
             }
         });
     }
+    /** Tint a terminal's dock tab with the colour of the Claude session it runs,
+     * delegating to jupyterlab_colourful_tab_extension's `setColour` API so that
+     * extension owns the tab CSS and colour vocabulary. A no-op when the
+     * colourful-tab extension is not installed (the token is optional). An
+     * absent/unknown colour clears the tint. */
+    _applyTerminalColour(widget, color) {
+        if (!this._colourfulTabs || !widget || widget.isDisposed) {
+            return;
+        }
+        this._colourfulTabs.setColour(widget, claudeTabColourId(color));
+    }
+    /** Re-tint EVERY open Claude terminal tab from the freshest session colours,
+     * whether the plugin launched it or the user opened it themselves. Walks
+     * JupyterLab's terminal tracker (the registry of all open terminals) rather
+     * than only the plugin's own launch cache, and re-resolves each terminal's
+     * Claude conversation on every pass via the ``terminal-cwd`` probe - so a tab
+     * whose terminal has since started (or switched) a Claude conversation is
+     * re-tinted correctly rather than pinned to a stale identity. The probe is a
+     * few /proc reads per terminal; runs after each fetch (launch refresh + the
+     * 30s poll), which is already gated to skip while a context menu is open. */
+    async _reconcileTerminalColours() {
+        var _a;
+        if (!this._colourfulTabs || !this._terminalTracker) {
+            return;
+        }
+        const sessions = (_a = this._sessions) !== null && _a !== void 0 ? _a : [];
+        const widgets = [];
+        this._terminalTracker.forEach((widget) => {
+            if (widget && !widget.isDisposed) {
+                widgets.push(widget);
+            }
+        });
+        await Promise.all(widgets.map(async (widget) => {
+            const info = await this._interrogateTerminal(widget);
+            if (!info || !info.hasClaude || widget.isDisposed) {
+                return;
+            }
+            this._applyTerminalColour(widget, this._colourForTerminal(info, sessions));
+        }));
+    }
+    /** Resolve a terminal's Claude identity: does it run Claude, which
+     * conversation id, and its cwd(s). Panel-launched terminals are already known
+     * (their conversation was confirmed at launch), so those skip the backend
+     * probe; every other terminal is probed once via ``terminal-cwd``. Returns
+     * ``null`` when the terminal has no session name yet or the probe fails. */
+    async _interrogateTerminal(widget) {
+        var _a, _b, _c;
+        for (const entry of this._terminalsByPath.values()) {
+            if (entry.widget === widget && entry.sessionId) {
+                return { hasClaude: true, sessionId: entry.sessionId, cwds: [] };
+            }
+        }
+        const sessName = (_b = (_a = widget === null || widget === void 0 ? void 0 : widget.content) === null || _a === void 0 ? void 0 : _a.session) === null || _b === void 0 ? void 0 : _b.name;
+        if (typeof sessName !== 'string' || !sessName) {
+            return null;
+        }
+        try {
+            const data = await requestAPI(`terminal-cwd/${encodeURIComponent(sessName)}`, this._serverSettings);
+            return {
+                hasClaude: !!(data === null || data === void 0 ? void 0 : data.has_claude),
+                sessionId: (_c = data === null || data === void 0 ? void 0 : data.session_id) !== null && _c !== void 0 ? _c : null,
+                cwds: Array.isArray(data === null || data === void 0 ? void 0 : data.cwds) ? data.cwds : []
+            };
+        }
+        catch (_err) {
+            // Backend may 404 for a terminal that vanished between enumeration and
+            // probe - treat as unresolved and retry on the next poll.
+            return null;
+        }
+    }
+    /** Pick a terminal's tab colour from the session list. When the terminal runs
+     * a known conversation (its argv carried a ``--resume`` / ``--session-id``),
+     * match on that id ONLY: it takes the colour of the exact conversation, or -
+     * when that conversation is not the project's representative row - clears,
+     * rather than borrowing a sibling branch's colour. The cwd fallback is used
+     * ONLY for a terminal with no conversation id (a bare ``claude`` / ``-c``),
+     * matching the project the terminal is cwd'd in and preferring the longest
+     * matching path so a nested project wins over its parent. Returns null (clear)
+     * when no row matches or the matched row has no colour. */
+    _colourForTerminal(info, sessions) {
+        var _a, _b;
+        if (info.sessionId) {
+            const bySession = sessions.find(s => s.session_id === info.sessionId);
+            return bySession ? ((_a = bySession.color) !== null && _a !== void 0 ? _a : null) : null;
+        }
+        let best;
+        let bestLen = -1;
+        for (const raw of info.cwds) {
+            const cwd = raw.replace(/\/+$/, '');
+            for (const s of sessions) {
+                const p = s.project_path.replace(/\/+$/, '');
+                if ((cwd === p || cwd.startsWith(p + '/')) && p.length > bestLen) {
+                    best = s;
+                    bestLen = p.length;
+                }
+            }
+        }
+        return best ? ((_b = best.color) !== null && _b !== void 0 ? _b : null) : null;
+    }
     async _findTerminalForCwd(projectPath, wantedSessionId) {
         var _a, _b, _c;
         if (!this._terminalTracker) {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "jupyterlab_claude_code_extension",
-    "version": "1.2.41",
+    "version": "1.2.43",
     "description": "Browse, resume, and manage your Claude Code CLI sessions from a JupyterLab side panel. One click reactivates the right terminal - no duplicate tabs, live remote-control indicator, and favourites for the projects you keep coming back to.",
     "keywords": [
         "jupyter",
@@ -64,7 +64,8 @@
         "@jupyterlab/terminal": "^4.0.0",
         "@jupyterlab/ui-components": "^4.0.0",
         "@lumino/commands": "^2.0.0",
-        "@lumino/widgets": "^2.0.0"
+        "@lumino/widgets": "^2.0.0",
+        "jupyterlab_colourful_tab_extension": "^1.0.19"
     },
     "devDependencies": {
         "@jupyterlab/builder": "^4.0.0",
@@ -125,7 +126,13 @@
         },
         "extension": true,
         "schemaDir": "schema",
-        "outputDir": "jupyterlab_claude_code_extension/labextension"
+        "outputDir": "jupyterlab_claude_code_extension/labextension",
+        "sharedPackages": {
+            "jupyterlab_colourful_tab_extension": {
+                "bundled": false,
+                "singleton": true
+            }
+        }
     },
     "eslintIgnore": [
         "node_modules",

package/src/__tests__/jupyterlab_claude_code_extension.spec.ts

@@ -23,6 +23,7 @@ const session = (over: Partial<ISession> = {}): ISession => ({
   remote_control: false,
   favourite: false,
   extra_sessions: 0,
+  color: null,
   ...over
 });
 

package/src/index.ts

@@ -7,6 +7,7 @@ import {
 import { IDefaultFileBrowser } from '@jupyterlab/filebrowser';
 import { ISettingRegistry } from '@jupyterlab/settingregistry';
 import { ITerminalTracker } from '@jupyterlab/terminal';
+import { IColourfulTabs } from 'jupyterlab_colourful_tab_extension';
 
 import { requestAPI } from './request';
 import { IStatusResponse } from './types';
@@ -25,7 +26,8 @@ const plugin: JupyterFrontEndPlugin<void> = {
     ILayoutRestorer,
     ISettingRegistry,
     ITerminalTracker,
-    IDefaultFileBrowser
+    IDefaultFileBrowser,
+    IColourfulTabs
   ],
   activate: async (
     app: JupyterFrontEnd,
@@ -33,7 +35,8 @@ const plugin: JupyterFrontEndPlugin<void> = {
     restorer: ILayoutRestorer | null,
     settingRegistry: ISettingRegistry | null,
     terminalTracker: ITerminalTracker | null,
-    fileBrowser: IDefaultFileBrowser | null
+    fileBrowser: IDefaultFileBrowser | null,
+    colourfulTabs: IColourfulTabs | null
   ) => {
     const settings = app.serviceManager.serverSettings;
 
@@ -59,7 +62,8 @@ const plugin: JupyterFrontEndPlugin<void> = {
       app,
       status.root_dir || '',
       terminalTracker,
-      fileBrowser
+      fileBrowser,
+      colourfulTabs
     );
 
     // Read the sidebar setting before docking so we add the widget to the

package/src/types.ts

@@ -14,6 +14,9 @@ export interface ISession {
   remote_control: boolean;
   favourite: boolean;
   extra_sessions: number;
+  /** Claude session colour from `/color` or auto-assignment (e.g. "blue"), or
+   * null when the session carries none. Drives the terminal tab tint. */
+  color: string | null;
 }
 
 export interface ISessionsListResponse {

package/src/widget.ts

@@ -9,6 +9,7 @@ import {
 import { ServerConnection } from '@jupyterlab/services';
 import { IDefaultFileBrowser } from '@jupyterlab/filebrowser';
 import { ITerminalTracker } from '@jupyterlab/terminal';
+import { IColourfulTabs } from 'jupyterlab_colourful_tab_extension';
 import { copyIcon, folderIcon, terminalIcon } from '@jupyterlab/ui-components';
 import { CommandRegistry } from '@lumino/commands';
 import { UUID } from '@lumino/coreutils';
@@ -54,6 +55,23 @@ export type PresentationMode = 'name' | 'path';
 
 const DEFAULT_PRESENTATION_MODE: PresentationMode = 'name';
 
+// Claude's per-session colour (set by `/color`, or auto-assigned for
+// multi-session use) maps to a jupyterlab_colourful_tab_extension colour id.
+// That extension owns the tab-tint CSS and the setColour API; we only feed it
+// the colour. An absent or unrecognised colour resolves to null (clear tint).
+const CLAUDE_TAB_COLOUR_ID: Record<string, string> = {
+  red: 'rose',
+  orange: 'peach',
+  yellow: 'lemon',
+  green: 'mint',
+  blue: 'sky',
+  purple: 'lavender'
+};
+
+function claudeTabColourId(color: string | null | undefined): string | null {
+  return (color && CLAUDE_TAB_COLOUR_ID[color]) || null;
+}
+
 const SECTION_LABELS: Record<SectionKey, string> = {
   favourites: 'Favorites',
   recent: 'Recent',
@@ -119,7 +137,8 @@ export class ClaudeCodeSessionsWidget extends Widget {
     app: JupyterFrontEnd,
     rootDir: string,
     terminalTracker: ITerminalTracker | null = null,
-    fileBrowser: IDefaultFileBrowser | null = null
+    fileBrowser: IDefaultFileBrowser | null = null,
+    colourfulTabs: IColourfulTabs | null = null
   ) {
     super();
     this._app = app;
@@ -127,6 +146,7 @@ export class ClaudeCodeSessionsWidget extends Widget {
     this._rootDir = rootDir.replace(/\/+$/, '');
     this._terminalTracker = terminalTracker;
     this._fileBrowser = fileBrowser;
+    this._colourfulTabs = colourfulTabs;
 
     this.id = 'jupyterlab-claude-code-extension';
     this.title.icon = claudeIcon;
@@ -408,6 +428,8 @@ export class ClaudeCodeSessionsWidget extends Widget {
     );
     this._sessions = data.sessions ?? [];
     this._render();
+    // Best-effort tab tinting; never let a colour failure break the fetch.
+    this._reconcileTerminalColours().catch(() => undefined);
   }
 
   private async _toggleFavourite(session: ISession): Promise<void> {
@@ -762,6 +784,123 @@ export class ClaudeCodeSessionsWidget extends Widget {
     });
   }
 
+  /** Tint a terminal's dock tab with the colour of the Claude session it runs,
+   * delegating to jupyterlab_colourful_tab_extension's `setColour` API so that
+   * extension owns the tab CSS and colour vocabulary. A no-op when the
+   * colourful-tab extension is not installed (the token is optional). An
+   * absent/unknown colour clears the tint. */
+  private _applyTerminalColour(
+    widget: any,
+    color: string | null | undefined
+  ): void {
+    if (!this._colourfulTabs || !widget || widget.isDisposed) {
+      return;
+    }
+    this._colourfulTabs.setColour(widget, claudeTabColourId(color));
+  }
+
+  /** Re-tint EVERY open Claude terminal tab from the freshest session colours,
+   * whether the plugin launched it or the user opened it themselves. Walks
+   * JupyterLab's terminal tracker (the registry of all open terminals) rather
+   * than only the plugin's own launch cache, and re-resolves each terminal's
+   * Claude conversation on every pass via the ``terminal-cwd`` probe - so a tab
+   * whose terminal has since started (or switched) a Claude conversation is
+   * re-tinted correctly rather than pinned to a stale identity. The probe is a
+   * few /proc reads per terminal; runs after each fetch (launch refresh + the
+   * 30s poll), which is already gated to skip while a context menu is open. */
+  private async _reconcileTerminalColours(): Promise<void> {
+    if (!this._colourfulTabs || !this._terminalTracker) {
+      return;
+    }
+    const sessions = this._sessions ?? [];
+    const widgets: any[] = [];
+    this._terminalTracker.forEach((widget: any) => {
+      if (widget && !widget.isDisposed) {
+        widgets.push(widget);
+      }
+    });
+    await Promise.all(
+      widgets.map(async widget => {
+        const info = await this._interrogateTerminal(widget);
+        if (!info || !info.hasClaude || widget.isDisposed) {
+          return;
+        }
+        this._applyTerminalColour(
+          widget,
+          this._colourForTerminal(info, sessions)
+        );
+      })
+    );
+  }
+
+  /** Resolve a terminal's Claude identity: does it run Claude, which
+   * conversation id, and its cwd(s). Panel-launched terminals are already known
+   * (their conversation was confirmed at launch), so those skip the backend
+   * probe; every other terminal is probed once via ``terminal-cwd``. Returns
+   * ``null`` when the terminal has no session name yet or the probe fails. */
+  private async _interrogateTerminal(widget: any): Promise<{
+    hasClaude: boolean;
+    sessionId: string | null;
+    cwds: string[];
+  } | null> {
+    for (const entry of this._terminalsByPath.values()) {
+      if (entry.widget === widget && entry.sessionId) {
+        return { hasClaude: true, sessionId: entry.sessionId, cwds: [] };
+      }
+    }
+    const sessName: string | undefined = widget?.content?.session?.name;
+    if (typeof sessName !== 'string' || !sessName) {
+      return null;
+    }
+    try {
+      const data = await requestAPI<ITerminalCwdResponse>(
+        `terminal-cwd/${encodeURIComponent(sessName)}`,
+        this._serverSettings
+      );
+      return {
+        hasClaude: !!data?.has_claude,
+        sessionId: data?.session_id ?? null,
+        cwds: Array.isArray(data?.cwds) ? data.cwds : []
+      };
+    } catch (_err) {
+      // Backend may 404 for a terminal that vanished between enumeration and
+      // probe - treat as unresolved and retry on the next poll.
+      return null;
+    }
+  }
+
+  /** Pick a terminal's tab colour from the session list. When the terminal runs
+   * a known conversation (its argv carried a ``--resume`` / ``--session-id``),
+   * match on that id ONLY: it takes the colour of the exact conversation, or -
+   * when that conversation is not the project's representative row - clears,
+   * rather than borrowing a sibling branch's colour. The cwd fallback is used
+   * ONLY for a terminal with no conversation id (a bare ``claude`` / ``-c``),
+   * matching the project the terminal is cwd'd in and preferring the longest
+   * matching path so a nested project wins over its parent. Returns null (clear)
+   * when no row matches or the matched row has no colour. */
+  private _colourForTerminal(
+    info: { sessionId: string | null; cwds: string[] },
+    sessions: ISession[]
+  ): string | null {
+    if (info.sessionId) {
+      const bySession = sessions.find(s => s.session_id === info.sessionId);
+      return bySession ? (bySession.color ?? null) : null;
+    }
+    let best: ISession | undefined;
+    let bestLen = -1;
+    for (const raw of info.cwds) {
+      const cwd = raw.replace(/\/+$/, '');
+      for (const s of sessions) {
+        const p = s.project_path.replace(/\/+$/, '');
+        if ((cwd === p || cwd.startsWith(p + '/')) && p.length > bestLen) {
+          best = s;
+          bestLen = p.length;
+        }
+      }
+    }
+    return best ? (best.color ?? null) : null;
+  }
+
   private async _findTerminalForCwd(
     projectPath: string,
     wantedSessionId: string | undefined
@@ -2205,6 +2344,7 @@ export class ClaudeCodeSessionsWidget extends Widget {
   private readonly _removingPaths: Set<string> = new Set();
   private readonly _terminalTracker: ITerminalTracker | null;
   private readonly _fileBrowser: IDefaultFileBrowser | null;
+  private readonly _colourfulTabs: IColourfulTabs | null;
   // Microcache of the most-recent terminal per project, tagged with the
   // conversation it is running so reuse can tell a project's branches apart.
   private readonly _terminalsByPath: Map<