jupyterlab_ai_code_assistants_extension 1.0.39 → 1.1.13

package/README.md

@@ -30,6 +30,7 @@ Chat-panel extensions re-implement the agent loop and trail the real tool. This
 - **Joint settings page** - one settings section covering all assistants, with a per-assistant toggle (all on by default); toggling takes effect live, no JupyterLab reload
 - **Three-section side panel** - Favorites, Recent, and All projects, each scrolling independently
 - **One-click resume** - click a row to jump back into that session in a terminal; an open terminal for the project is reused instead of duplicated
+- **Launcher tiles** - every enabled assistant has a tile in an "AI Assistants" section of the JupyterLab Launcher (after Other, under the extension's own robot-head icon); a click opens the assistant in the file browser's current folder, resuming the folder's conversation when one exists and starting a new one otherwise, through the companion `jupyterlab_basic_terminal_extension` (installed automatically). Disable an assistant and its tile goes; disable them all and the section goes with them
 - **Your terminal's `claude -c` follows the panel** (Claude) - switching to or launching a conversation makes plain `claude -c` in that project resume that same conversation, including one that has been compacted, which Claude Code otherwise refuses to continue
 - **Conversation switcher** - a right-click "Switch and Manage Sessions" submenu lists a project's other conversations by name and short id with last-activity time; "Manage Sessions..." opens a searchable popup over the full list with multi-select delete and per-row open and copy-id buttons
 - **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 `codex fork`, server-side copies for Kimi and Gemini) behind the same menu item

package/lib/core/icons.d.ts

@@ -11,3 +11,17 @@ export declare const switchIcon: LabIcon;
 export declare const filterIcon: LabIcon;
 /** Build (or reuse) the LabIcon for a provider's own glyph. */
 export declare function providerIcon(name: string, svgstr: string): LabIcon;
+/**
+ * A provider's tile icon as the Launcher should draw it.
+ *
+ * The Launcher has no section icon of its own: a category's header is drawn
+ * with the FIRST tile's command icon under the `launcherSection` stylesheet
+ * preset, and each tile under `launcherCard`. This view of `tile` renders the
+ * extension's joint icon under the section preset and `tile` everywhere else,
+ * so the header carries no vendor's mark while every tile keeps its own
+ * (ACC-LNCH-163).
+ *
+ * Built the way `LabIcon.bindprops` builds its views - a prototype child of
+ * the tile with its own `react` - so `LabIcon.resolve` still recognises it.
+ */
+export declare function launcherTileIcon(tile: LabIcon): LabIcon;

package/lib/core/icons.js

@@ -1,4 +1,5 @@
 import { LabIcon } from '@jupyterlab/ui-components';
+import * as React from 'react';
 // Shared panel chrome icons. Provider icons are NOT here - each provider
 // carries its own SVG on its descriptor and the registry builds the LabIcon
 // from it, so adding an assistant touches no core file.
@@ -6,11 +7,13 @@ import { LabIcon } from '@jupyterlab/ui-components';
 // Material-style glyphs matched to the rest of the sidebar so header and menu
 // icons render at identical size and theme.
 const ICON_PREFIX = 'jupyterlab_ai_code_assistants_extension';
-// The extension's own identity, used by the settings entry - one section for
-// all assistants, so it cannot borrow any one assistant's glyph. Material
-// "smart_toy" outline.
+// The extension's own identity, used by the settings entry and the Launcher
+// section header - one section for all assistants, so it cannot borrow any one
+// assistant's glyph. A robot head in the Material filled style: antenna, side
+// bolts, eye and mouth cut-outs. One evenodd path, so the cut-outs are holes
+// and the theme's `.jp-icon3[fill]` rule recolours the whole glyph at once.
 const assistantsSvgStr = `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" width="16" height="16">
-  <path class="jp-icon3" fill="#616161" d="M20 9V7c0-1.1-.9-2-2-2h-3c0-1.66-1.34-3-3-3S9 3.34 9 5H6c-1.1 0-2 .9-2 2v2c-1.66 0-3 1.34-3 3s1.34 3 3 3v4c0 1.1.9 2 2 2h12c1.1 0 2-.9 2-2v-4c1.66 0 3-1.34 3-3s-1.34-3-3-3zm-2 10H6V7h12v12zM9 13.5c-.83 0-1.5-.67-1.5-1.5s.67-1.5 1.5-1.5 1.5.67 1.5 1.5-.67 1.5-1.5 1.5zm7.5-1.5c0 .83-.67 1.5-1.5 1.5s-1.5-.67-1.5-1.5.67-1.5 1.5-1.5 1.5.67 1.5 1.5zM8 15h8v2H8v-2z"/>
+  <path class="jp-icon3" fill="#616161" fill-rule="evenodd" d="M12 1.5a1.6 1.6 0 1 1 0 3.2 1.6 1.6 0 0 1 0-3.2ZM11.2 4.7h1.6V7h-1.6ZM7 7h10a3 3 0 0 1 3 3v8a3 3 0 0 1-3 3H7a3 3 0 0 1-3-3v-8a3 3 0 0 1 3-3ZM2 11h2v5H2ZM20 11h2v5h-2ZM9 10.2a1.8 1.8 0 1 0 0 3.6 1.8 1.8 0 0 0 0-3.6ZM15 10.2a1.8 1.8 0 1 0 0 3.6 1.8 1.8 0 0 0 0-3.6ZM8.6 15.6h6.8a.9.9 0 0 1 0 1.8H8.6a.9.9 0 0 1 0-1.8Z"/>
 </svg>`;
 export const assistantsIcon = new LabIcon({
     name: `${ICON_PREFIX}:assistants`,
@@ -114,3 +117,25 @@ export function providerIcon(name, svgstr) {
     }
     return icon;
 }
+/**
+ * A provider's tile icon as the Launcher should draw it.
+ *
+ * The Launcher has no section icon of its own: a category's header is drawn
+ * with the FIRST tile's command icon under the `launcherSection` stylesheet
+ * preset, and each tile under `launcherCard`. This view of `tile` renders the
+ * extension's joint icon under the section preset and `tile` everywhere else,
+ * so the header carries no vendor's mark while every tile keeps its own
+ * (ACC-LNCH-163).
+ *
+ * Built the way `LabIcon.bindprops` builds its views - a prototype child of
+ * the tile with its own `react` - so `LabIcon.resolve` still recognises it.
+ */
+export function launcherTileIcon(tile) {
+    const view = Object.create(tile);
+    const react = React.forwardRef((props, ref) => React.createElement(props.stylesheet === 'launcherSection'
+        ? assistantsIcon.react
+        : tile.react, { ...props, ref }));
+    // `react` is readonly on the type; the view shadows the tile's own.
+    Object.defineProperty(view, 'react', { value: react });
+    return view;
+}

package/lib/core/panel.d.ts

@@ -89,17 +89,36 @@ export declare class AssistantSessionsPanel extends Widget {
      * JupyterLab's move-to-trash setting. Settable because a panel docked before
      * the server has answered its first status probe is built without either
      * (DEF-132); the action paths read them lazily, so a late value applies on
-     * the next click, while rows already rendered keep absolute paths until the
-     * next poll.
+     * the next click, and a root arriving after rows were drawn redraws them
+     * once (DEF-136).
      *
      * Trailing slashes go, but never the root itself: serving JupyterLab at
      * `/` used to normalise to the empty string, which reads as "no root" -
      * the + button then did nothing at all, and Open Terminal and Show in File
      * Browser answered "outside the JupyterLab root" for every row inside it. */
     setRoot(rootDir: string, deleteToTrash: boolean): void;
-    /** Absolute path of the file browser's current folder; the server root when
-     * no file browser is available. */
+    /** Absolute path of a folder given as a Contents-API path, defaulting to the
+     * file browser's current folder; the server root when neither is available.
+     *
+     * `path` is passed by the Launcher tile, which carries the folder its click
+     * happened in rather than whatever the browser shows now. An empty string is
+     * the root, so the default applies only when nothing at all was given. */
     private _currentFolder;
+    /**
+     * Start or resume this assistant in `cwd`, and answer with the terminal
+     * widget the sibling extension opened - the Launcher replaces its own tab
+     * with whatever the command resolves to (ACC-LNCH-157).
+     *
+     * The tile's whole click path lives here rather than in `src/index.ts`
+     * because every input it needs is already the panel's: the root join, the
+     * listing fetch, the terminal reuse ladder and the settings-resolved launch
+     * mode. Nothing here retries and nothing is scheduled: a guard that refuses
+     * shows one notification and launches nothing, and a request that fails
+     * writes nothing.
+     *
+     * `cwd` is a Contents-API path, `''` for the root.
+     */
+    launchHere(cwd?: string): Promise<any>;
     /** Start a brand-new conversation in the file browser's current folder. */
     private _newSession;
     /**

package/lib/core/panel.js

@@ -36,6 +36,11 @@ const BRANCH_WATCH_INTERVAL_MS = 2000;
 const BRANCH_WATCH_MAX_ATTEMPTS = 90; // ~3 minutes
 /** Conversations listed inline in a branch submenu before the popup takes over. */
 const INLINE_BRANCH_LIMIT = 5;
+/** Command id of the sibling extension that spawns a shell-less terminal on a
+ * bare argv, with args `{argv, cwd}`. That string IS the coupling: the sibling
+ * exports no token, so its absence is something to ask the command registry
+ * about at click time rather than a build-time dependency (ACC-LNCH-155). */
+const BASIC_TERMINAL_LAUNCH = 'basic-terminal:launch';
 export const DEFAULT_PRESENTATION_MODE = 'name';
 const SECTION_LABELS = {
     favourites: 'Favorites',
@@ -508,6 +513,18 @@ export class AssistantSessionsPanel extends Widget {
     _showError(err) {
         const message = err instanceof Error ? err.message : String(err);
         this._logError(message);
+        // DEF-138: the server ANSWERED, and its answer is that this assistant's
+        // binary is not on the PATH the Jupyter server runs with. Blaming the
+        // server names the wrong cause - the panel is docked only because no
+        // roster has arrived yet, and the roster is what removes it (DEF-132).
+        // The error code is matched as well as the status, because a 503 raised
+        // by a proxy or a stopped single-user server is NOT this: its body never
+        // parses to `{"error": "cli_not_found"}`, so it keeps the copy below.
+        if (isResponseStatus(err, 503) && message === 'cli_not_found') {
+            this._setInlineError(`\`${this._descriptor.cliBinary}\` was not found on the Jupyter ` +
+                `server's PATH.`);
+            return;
+        }
         const copy = isRequestTimeout(err)
             ? 'The server is not answering - retrying.'
             : 'Could not reach the server - retrying.';
@@ -714,8 +731,8 @@ export class AssistantSessionsPanel extends Widget {
      * JupyterLab's move-to-trash setting. Settable because a panel docked before
      * the server has answered its first status probe is built without either
      * (DEF-132); the action paths read them lazily, so a late value applies on
-     * the next click, while rows already rendered keep absolute paths until the
-     * next poll.
+     * the next click, and a root arriving after rows were drawn redraws them
+     * once (DEF-136).
      *
      * Trailing slashes go, but never the root itself: serving JupyterLab at
      * `/` used to normalise to the empty string, which reads as "no root" -
@@ -724,25 +741,146 @@ export class AssistantSessionsPanel extends Widget {
     setRoot(rootDir, deleteToTrash) {
         var _a;
         const root = (rootDir || '').replace(/\/+$/, '');
-        this._rootDir = root || (rootDir ? '/' : '');
+        const next = root || (rootDir ? '/' : '');
+        const changed = next !== this._rootDir;
+        this._rootDir = next;
         this._deleteToTrash = deleteToTrash;
         (_a = this._renameNewButton) === null || _a === void 0 ? void 0 : _a.call(this);
+        // Guarded on the VALUE, not on the call: `reconcile` re-sends the same
+        // root every status tick, so a changed-guard redraws exactly once, on the
+        // '' -> root transition. `_sessions` stands in for "the shell is built and
+        // rows are on screen" - it is null until the first `_fetch` answers, which
+        // is what keeps the constructor's own `setRoot` from reaching `_render`
+        // before `_buildShell` has created `_bodyEl`.
+        if (changed && this._sessions !== null) {
+            this._render();
+        }
     }
-    /** Absolute path of the file browser's current folder; the server root when
-     * no file browser is available. */
-    _currentFolder() {
+    /** Absolute path of a folder given as a Contents-API path, defaulting to the
+     * file browser's current folder; the server root when neither is available.
+     *
+     * `path` is passed by the Launcher tile, which carries the folder its click
+     * happened in rather than whatever the browser shows now. An empty string is
+     * the root, so the default applies only when nothing at all was given. */
+    _currentFolder(path) {
         var _a, _b, _c;
         // No roster yet (DEF-132): a relative folder joined to an empty root
         // would be an absolute path at the filesystem root.
         if (!this._rootDir) {
             return '';
         }
-        const rel = ((_c = (_b = (_a = this._fileBrowser) === null || _a === void 0 ? void 0 : _a.model) === null || _b === void 0 ? void 0 : _b.path) !== null && _c !== void 0 ? _c : '').replace(/^\/+/, '');
+        const rel = ((_c = path !== null && path !== void 0 ? path : (_b = (_a = this._fileBrowser) === null || _a === void 0 ? void 0 : _a.model) === null || _b === void 0 ? void 0 : _b.path) !== null && _c !== void 0 ? _c : '').replace(/^\/+/, '');
         if (!rel) {
             return this._rootDir;
         }
         return this._rootDir === '/' ? `/${rel}` : `${this._rootDir}/${rel}`;
     }
+    /**
+     * Start or resume this assistant in `cwd`, and answer with the terminal
+     * widget the sibling extension opened - the Launcher replaces its own tab
+     * with whatever the command resolves to (ACC-LNCH-157).
+     *
+     * The tile's whole click path lives here rather than in `src/index.ts`
+     * because every input it needs is already the panel's: the root join, the
+     * listing fetch, the terminal reuse ladder and the settings-resolved launch
+     * mode. Nothing here retries and nothing is scheduled: a guard that refuses
+     * shows one notification and launches nothing, and a request that fails
+     * writes nothing.
+     *
+     * `cwd` is a Contents-API path, `''` for the root.
+     */
+    async launchHere(cwd) {
+        var _a, _b;
+        // No roster yet, so the root is unknown. Joining onto an empty one names a
+        // folder at the filesystem root, which the server accepts whenever it
+        // happens to exist (ACC-LNCH-148, DEF-132).
+        if (!this._rootDir) {
+            Notification.warning('Waiting for the server root - nothing was launched.', { autoClose: 4000 });
+            return undefined;
+        }
+        // A registered drive (jupyter-fs, S3) is not assumed to map onto the
+        // server filesystem, and its local path would resolve against the server's
+        // own root - an unrelated directory of the same name (ACC-LNCH-149).
+        if (typeof cwd === 'string' &&
+            this._app.serviceManager.contents.driveName(cwd) !== '') {
+            Notification.warning('The file browser is on a drive that does not map onto the Jupyter ' +
+                "server's filesystem, so nothing was launched.", { autoClose: 4000 });
+            return undefined;
+        }
+        if (!this._app.commands.hasCommand(BASIC_TERMINAL_LAUNCH)) {
+            Notification.warning('jupyterlab_basic_terminal_extension is not installed, and it owns ' +
+                `the \`${BASIC_TERMINAL_LAUNCH}\` command this launch runs on.`, { autoClose: 4000 });
+            return undefined;
+        }
+        const folder = this._currentFolder(cwd);
+        let argv;
+        try {
+            // Every click asks the server for the listing (ACC-LNCH-151). `_sessions`
+            // is written by `_fetch` and by the optimistic remove in
+            // `_removeProject`, and the poll that calls `_fetch` stops on
+            // `onBeforeHide` - so a hidden panel's cache is as old as the moment it
+            // was hidden, and reading it resumed a conversation that had since moved
+            // or minted a second one for a folder that already had a row.
+            await this._fetch();
+            const rows = (_a = this._sessions) !== null && _a !== void 0 ? _a : [];
+            // A row for this folder means the folder has a conversation, which is
+            // what makes this a resume rather than a new session (ACC-LNCH-151).
+            const row = (_b = rows.find(s => s.project_path === folder)) !== null && _b !== void 0 ? _b : null;
+            if (row) {
+                // A terminal already holding that conversation IS the answer: a second
+                // process on one history is never what the click meant (ACC-LNCH-152).
+                const found = await this._terminals.findForSession(row.session_id);
+                if (found) {
+                    this._terminals.focus(found.widget);
+                    return found.widget;
+                }
+            }
+            const request = {
+                project_path: folder,
+                encoded_path: row === null || row === void 0 ? void 0 : row.encoded_path,
+                session_id: row === null || row === void 0 ? void 0 : row.session_id,
+                // Minted here when the CLI takes an id, so the new conversation is
+                // identifiable from its argv on the first poll (ACC-LNCH-153).
+                new_session_id: row || !this._descriptor.mintsNewSessionId ? undefined : UUID.uuid4(),
+                // No forced mode - the same default the + button launches under
+                // (ACC-LNCH-147).
+                mode: this._launchMode()
+            };
+            const answer = await requestProvider(this._descriptor.id, 'launch-argv', this._serverSettings, { method: 'POST', body: JSON.stringify(request) });
+            argv = answer.argv;
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            // The binary went away after the panel docked. Named, because the
+            // symptom otherwise reads as a broken tile.
+            if (isResponseStatus(err, 503) && message === 'cli_not_found') {
+                Notification.warning(`\`${this._descriptor.cliBinary}\` was not found on the Jupyter ` +
+                    "server's PATH, so nothing was launched.", { autoClose: 4000 });
+                return undefined;
+            }
+            this._notifyLaunchError('Could not start a session in this folder', err);
+            return undefined;
+        }
+        // The folder is already resolved against the server root, and the sibling
+        // takes an absolute path (ACC-LNCH-154).
+        //
+        // Its own catch, because the cause is a different one: the block above
+        // refuses before anything was spawned, this one refuses after the argv was
+        // agreed. The Launcher shows a modal "Launcher Error" for any rejection
+        // that escapes the command, so the refusal is reported as one notification
+        // and the Launcher keeps its tab (ACC-LNCH-157 covers the success path
+        // only).
+        try {
+            return await this._app.commands.execute(BASIC_TERMINAL_LAUNCH, {
+                argv,
+                cwd: folder
+            });
+        }
+        catch (err) {
+            this._notifyLaunchError('Could not open a terminal for this folder', err);
+            return undefined;
+        }
+    }
     /** Start a brand-new conversation in the file browser's current folder. */
     async _newSession(force) {
         var _a;
@@ -1770,7 +1908,11 @@ export class AssistantSessionsPanel extends Widget {
                 // absolute filesystem path, so it goes through _pathUnderRoot.
                 const rel = this._pathUnderRoot(s.project_path);
                 if (rel === null) {
-                    Notification.warning('Folder is outside the JupyterLab root - cannot open a terminal there.', { autoClose: 4000 });
+                    // A root the server has not sent yet is not a folder outside it
+                    // (DEF-134).
+                    Notification.warning(this._rootDir
+                        ? 'Folder is outside the JupyterLab root - cannot open a terminal there.'
+                        : 'Waiting for the server root - cannot open a terminal yet.', { autoClose: 4000 });
                     return;
                 }
                 this._app.commands
@@ -1788,7 +1930,11 @@ export class AssistantSessionsPanel extends Widget {
                 }
                 const rel = this._pathUnderRoot(s.project_path);
                 if (rel === null) {
-                    Notification.warning('Folder is outside the JupyterLab root - the file browser cannot show it.', { autoClose: 4000 });
+                    // A root the server has not sent yet is not a folder outside it
+                    // (DEF-134).
+                    Notification.warning(this._rootDir
+                        ? 'Folder is outside the JupyterLab root - the file browser cannot show it.'
+                        : 'Waiting for the server root - the file browser cannot show it yet.', { autoClose: 4000 });
                     return;
                 }
                 this._app.commands

package/lib/core/request.d.ts

@@ -56,6 +56,7 @@ export declare function isRequestTimeout(err: unknown): boolean;
  * @returns The response body interpreted as JSON
  * @throws RequestTimeoutError when the deadline passes before the server
  *   answers
+ * @throws Error when a 200 carries a body this helper cannot parse
  */
 export declare function requestAPI<T>(endPoint: string, serverSettings: ServerConnection.ISettings, init?: RequestInit): Promise<T>;
 /** Build a provider-scoped path: `providers/<id>/<path>`. The id is encoded so

package/lib/core/request.js

@@ -63,6 +63,7 @@ export function isRequestTimeout(err) {
  * @returns The response body interpreted as JSON
  * @throws RequestTimeoutError when the deadline passes before the server
  *   answers
+ * @throws Error when a 200 carries a body this helper cannot parse
  */
 export async function requestAPI(endPoint, serverSettings, init = {}) {
     var _a, _b;
@@ -111,7 +112,24 @@ export async function requestAPI(endPoint, serverSettings, init = {}) {
             data = JSON.parse(data);
         }
         catch (_c) {
-            console.log(`${LOG_PREFIX} Not a JSON response body.`, response);
+            if (response.ok) {
+                // DEF-118: every handler in `core/routes.py` finishes `json.dumps`, so
+                // a 200 this helper cannot parse did not come from this server - it is
+                // an SSO or proxy interstitial served in its place. Returning the raw
+                // string let every caller read `undefined` off it: `probeStatus` wrote
+                // a roster with no `providers` and `reconcile` undocked all four
+                // panels, `_fetch` rendered an empty session list, and
+                // `ColourStore.load` replaced the cache with an empty map. Refusing it
+                // makes the probe FAIL, and a failed probe writes nothing (DEF-132),
+                // so the last known roster stands.
+                throw new Error(`Response to ${endPoint} was not JSON (HTTP ${response.status})`);
+            }
+            // Not ok: the `ResponseError` below carries this body as its message, so
+            // this side is no longer a silent path and a proxy's error page here is
+            // noise (DEF-116). This is the conditional DEF-118 recorded - `debug`
+            // only on the refusal side; the 200 side is now louder than the `warn`
+            // it asked for.
+            console.debug(`${LOG_PREFIX} Not a JSON response body.`, response);
         }
     }
     if (!response.ok) {

package/lib/core/types.d.ts

@@ -205,6 +205,14 @@ export interface ILaunchRequest {
 export interface ILaunchResponse {
     terminal_name: string;
 }
+/** `POST providers/<id>/launch-argv`: the command line a launch WOULD run,
+ * for a caller that owns the spawn itself. Same body as {@link ILaunchRequest}
+ * and the same server-side bookkeeping as `launch`; the difference is that
+ * nothing is spawned, so the argv can be handed to another extension's
+ * terminal (ACC-LNCH-154). */
+export interface ILaunchArgvResponse {
+    argv: string[];
+}
 /** What a terminal is running, as the server resolved it from `/proc`. */
 export interface ITerminalProbeResponse {
     terminal_name: string;

package/lib/index.js

@@ -1,9 +1,11 @@
 import { ILabShell, ILayoutRestorer } from '@jupyterlab/application';
 import { Notification } from '@jupyterlab/apputils';
 import { IDefaultFileBrowser } from '@jupyterlab/filebrowser';
+import { ILauncher } from '@jupyterlab/launcher';
 import { ISettingRegistry } from '@jupyterlab/settingregistry';
 import { ITerminalTracker } from '@jupyterlab/terminal';
 import { IColourfulTabs } from 'jupyterlab_colourful_tab_extension';
+import { launcherTileIcon, providerIcon } from './core/icons';
 import { DEFAULT_RECENT_LIMIT } from './core/limits';
 import { AssistantSessionsPanel, DEFAULT_PRESENTATION_MODE, commandId, panelWidgetId } from './core/panel';
 import { LOG_PREFIX, ProviderRegistry } from './core/registry';
@@ -17,6 +19,14 @@ const PANEL_RANK = 600;
 /** How often the server is re-asked which assistants are available, so a CLI
  * installed while JupyterLab runs surfaces without a reload. */
 const STATUS_INTERVAL_MS = 60000;
+/** Launcher section every assistant tile lands in. */
+const LAUNCHER_CATEGORY = 'AI Assistants';
+/** Where that section sits. The Launcher ranks Notebook 0, Console 20 and
+ * Other 100, and the smallest rank among a category's items decides where the
+ * category goes - so ONE value on every tile, above Other's, puts the
+ * assistants after Other and keeps them there whichever tile is added first;
+ * unranked third-party categories (rank Infinity) still follow (ACC-LNCH-156). */
+const LAUNCHER_CATEGORY_RANK = 200;
 const plugin = {
     id: PLUGIN_ID,
     description: 'One side panel per AI code assistant, over a shared provider registry: sessions, favourites, branching and one-click resume in a terminal.',
@@ -27,9 +37,10 @@ const plugin = {
         ISettingRegistry,
         ITerminalTracker,
         IDefaultFileBrowser,
-        IColourfulTabs
+        IColourfulTabs,
+        ILauncher
     ],
-    activate: async (app, labShell, restorer, settingRegistry, terminalTracker, fileBrowser, colourfulTabs) => {
+    activate: async (app, labShell, restorer, settingRegistry, terminalTracker, fileBrowser, colourfulTabs, launcher) => {
         console.log('JupyterLab extension jupyterlab_ai_code_assistants_extension is activated!');
         // A duplicate id throws here, at registration, rather than surfacing later
         // as two panels quietly fighting over one widget id.
@@ -135,7 +146,7 @@ const plugin = {
             labShell.add(panel, sidebar, { rank: PANEL_RANK });
         };
         const start = (id) => {
-            var _a;
+            var _a, _b;
             const module = registry.get(id);
             if (!module || live.has(id)) {
                 return;
@@ -163,7 +174,29 @@ const plugin = {
                     label: `Refresh ${module.descriptor.panelTitle}`,
                     execute: () => panel.refresh()
                 });
-                live.set(id, { panel, command });
+                // The Launcher tile's command. It is registered whether or not a
+                // launcher exists, because the tile is the only caller but the command
+                // is what carries the label, the icon and the click path.
+                const launchCommandId = commandId(id, 'launch-here');
+                const launchCommand = app.commands.addCommand(launchCommandId, {
+                    label: module.descriptor.label,
+                    caption: `Start or resume ${module.descriptor.label} in the current folder`,
+                    // The section header borrows this icon too; the view draws the
+                    // joint icon there and the provider's own on the tile.
+                    icon: launcherTileIcon(providerIcon(module.descriptor.iconName, module.descriptor.iconSvg)),
+                    // The Launcher puts the file browser's folder in `cwd` on every
+                    // click; the panel resolves it against the server root.
+                    execute: args => panel.launchHere(args.cwd)
+                });
+                // Tile order follows the barrel, so the Launcher section reads in the
+                // sidebar's order (ACC-LNCH-158).
+                const tile = (_b = launcher === null || launcher === void 0 ? void 0 : launcher.add({
+                    command: launchCommandId,
+                    category: LAUNCHER_CATEGORY,
+                    rank: registry.ids.indexOf(id),
+                    categoryRank: LAUNCHER_CATEGORY_RANK
+                })) !== null && _b !== void 0 ? _b : null;
+                live.set(id, { panel, command, launchCommand, tile });
             }
             catch (err) {
                 // One provider failing to start must leave the others working.
@@ -171,6 +204,7 @@ const plugin = {
             }
         };
         const stop = (id) => {
+            var _a;
             const entry = live.get(id);
             if (!entry) {
                 return;
@@ -179,6 +213,10 @@ const plugin = {
             // Disposing stops the polling and clears this provider's tab tints; the
             // terminals it launched keep running, untouched.
             entry.command.dispose();
+            // Tile before the command it runs, so the Launcher never re-renders an
+            // item whose command has already gone.
+            (_a = entry.tile) === null || _a === void 0 ? void 0 : _a.dispose();
+            entry.launchCommand.dispose();
             entry.panel.dispose();
         };
         /** Bring the docked panels in line with settings and CLI availability.
@@ -226,6 +264,17 @@ const plugin = {
                     // gets a notification, so the COMMON failure was the quiet one.
                     Notification.warning(`${label} is enabled but \`${binary}\` was not found on the Jupyter server's PATH, so its panel is not shown.`, { autoClose: 8000 });
                 }
+                // The latch is per ABSENCE, not per page load. Once the server reports
+                // the binary present again, a later disappearance gets its own warning:
+                // without this, one transient absence - a CLI upgrade unlinking the
+                // binary for a moment, or an obsolete roster from an overlapping probe -
+                // permanently suppresses the real one (DEF-125). It cannot make the
+                // warning repeat while the state is unchanged, which is what the
+                // once-per-id latch above exists to prevent: the two conditions are
+                // mutually exclusive.
+                if (probe !== null && probe.available !== false) {
+                    warnedUnavailable.delete(id);
+                }
                 if (enabled && available) {
                     if (live.has(id)) {
                         const panel = live.get(id).panel;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "jupyterlab_ai_code_assistants_extension",
-    "version": "1.0.39",
+    "version": "1.1.13",
     "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",
@@ -62,6 +62,7 @@
         "@jupyterlab/apputils": "^4.0.0",
         "@jupyterlab/coreutils": "^6.0.0",
         "@jupyterlab/filebrowser": "^4.0.0",
+        "@jupyterlab/launcher": "^4.6.0",
         "@jupyterlab/services": "^7.0.0",
         "@jupyterlab/settingregistry": "^4.0.0",
         "@jupyterlab/terminal": "^4.0.0",
@@ -71,7 +72,8 @@
         "@lumino/disposable": "^2.0.0",
         "@lumino/messaging": "^2.0.0",
         "@lumino/widgets": "^2.0.0",
-        "jupyterlab_colourful_tab_extension": "^1.0.19"
+        "jupyterlab_colourful_tab_extension": "^1.0.19",
+        "react": "^18.2.0"
     },
     "devDependencies": {
         "@eslint/js": "^9.0.0",
@@ -80,6 +82,7 @@
         "@jupyterlab/testutils": "^4.0.0",
         "@types/jest": "^29.2.0",
         "@types/json-schema": "^7.0.11",
+        "@types/react-dom": "^18.2.0",
         "eslint": "^9.0.0",
         "eslint-config-prettier": "^9.0.0",
         "eslint-plugin-prettier": "^5.0.0",
@@ -87,6 +90,7 @@
         "jest": "^29.2.0",
         "npm-run-all2": "^7.0.1",
         "prettier": "^3.0.0",
+        "react-dom": "^18.2.0",
         "rimraf": "^5.0.1",
         "stylelint": "^15.10.1",
         "stylelint-config-recommended": "^13.0.0",

package/src/__tests__/core-neutrality.spec.ts

@@ -1,5 +1,6 @@
 /**
- * No assistant is named in `src/core/`.
+ * No assistant is named in `src/core/` or in the composition root
+ * `src/index.ts` (ACC-LNCH-150).
  *
  * The architecture rests on it: adding or removing an assistant must touch one
  * provider module and one barrel line, never a core file. A single `if (id ===
@@ -112,13 +113,21 @@ function coreFiles(): string[] {
     .map(name => path.join(CORE_DIR, name));
 }
 
-describe('the core names no assistant', () => {
+describe('the core and the composition root name no assistant', () => {
   it('has core files to scan at all', () => {
     // Guards against the scan passing because it found nothing to read.
     expect(coreFiles().length).toBeGreaterThan(3);
   });
 
-  it.each(coreFiles().map(file => [path.basename(file), file]))(
+  // ACC-LNCH-150 names the composition root as well as `src/core/`, so
+  // `index.ts` joins this scan only; `coreFiles()` stays as it is because the
+  // registry test below forbids the providers import `index.ts` must make.
+  it.each(
+    [...coreFiles(), path.resolve(__dirname, '..', 'index.ts')].map(file => [
+      path.basename(file),
+      file
+    ])
+  )(
     '%s carries no assistant name outside comments',
     (_name: string, file: string) => {
       const code = fs.readFileSync(file, 'utf8');