jupyterlab_ai_code_assistants_extension 1.0.41 → 1.2.1

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

@@ -97,9 +97,28 @@ export declare class AssistantSessionsPanel extends Widget {
      * 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',
@@ -751,21 +756,131 @@ export class AssistantSessionsPanel extends Widget {
             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;

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.

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "jupyterlab_ai_code_assistants_extension",
-    "version": "1.0.41",
+    "version": "1.2.1",
     "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');

package/src/__tests__/index.spec.ts

@@ -40,9 +40,11 @@ jest.mock('../core/request', () => ({
 import { CommandRegistry } from '@lumino/commands';
 import { Signal } from '@lumino/signaling';
 
-import { AssistantSessionsPanel } from '../core/panel';
+import { providerIcon } from '../core/icons';
+import { AssistantSessionsPanel, commandId } from '../core/panel';
 import { requestAPI } from '../core/request';
 import plugin from '../index';
+import { PROVIDERS } from '../providers';
 
 const request = requestAPI as jest.Mock;
 
@@ -125,3 +127,171 @@ describe('DEF-GUARD-139 - reconcile hands a late roster to a docked panel', () =
     docked.forEach(w => w.dispose());
   });
 });
+
+describe('ACC-LNCH-143..146 - the Launcher tile has the panel lifecycle', () => {
+  /** A roster in which every assistant is present, or every one but `absent`. */
+  const roster = (absent?: string): unknown => ({
+    root_dir: '/srv/lab',
+    delete_to_trash: true,
+    providers: PROVIDERS.map(module => ({
+      id: module.descriptor.id,
+      available: module.descriptor.id !== absent
+    }))
+  });
+
+  interface IActivation {
+    app: any;
+    docked: AssistantSessionsPanel[];
+    /** Every `ILauncher.add` call, in order. */
+    added: any[];
+    /** Commands whose tile has been disposed. */
+    disposed: string[];
+    /** Replace the roster the next probe answers with. */
+    setRoster: (next: unknown) => void;
+  }
+
+  /** Activate the plugin with no settings registry - every assistant enabled
+   * by default - against a launcher double, or none at all. */
+  async function activate(withLauncher = true): Promise<IActivation> {
+    let current = roster();
+    request.mockImplementation((path: string) =>
+      path === 'status'
+        ? Promise.resolve(current)
+        : Promise.reject(new Error('no other route'))
+    );
+    const added: any[] = [];
+    const disposed: string[] = [];
+    const docked: AssistantSessionsPanel[] = [];
+    const launcher = withLauncher
+      ? ({
+          add: (options: any) => {
+            added.push(options);
+            return { dispose: () => disposed.push(options.command) };
+          }
+        } as any)
+      : null;
+    const app = {
+      serviceManager: { serverSettings: {} },
+      commands: new CommandRegistry(),
+      hasPlugin: () => false
+    } as any;
+    const labShell = {
+      add: (widget: AssistantSessionsPanel) => docked.push(widget)
+    } as any;
+    await (plugin.activate as any)(
+      app,
+      labShell,
+      null,
+      null,
+      null,
+      null,
+      null,
+      launcher
+    );
+    await flush();
+    return {
+      app,
+      docked,
+      added,
+      disposed,
+      setRoster: (next: unknown) => {
+        current = next;
+      }
+    };
+  }
+
+  it('adds one tile per docked assistant, labelled and iconed from its descriptor', async () => {
+    const live = await activate();
+    expect(live.added).toHaveLength(PROVIDERS.length);
+    for (const module of PROVIDERS) {
+      const id = commandId(module.descriptor.id, 'launch-here');
+      const tile = live.added.find(item => item.command === id);
+      expect(tile).toBeDefined();
+      expect(tile.category).toBe('AI Assistants');
+      expect(live.app.commands.label(id)).toBe(module.descriptor.label);
+      // A `launcherTileIcon` view of the provider's own icon - the header
+      // draws the joint icon through it (launcher-icon.spec.ts).
+      expect(Object.getPrototypeOf(live.app.commands.icon(id))).toBe(
+        providerIcon(module.descriptor.iconName, module.descriptor.iconSvg)
+      );
+    }
+    live.docked.forEach(widget => widget.dispose());
+  });
+
+  it('disposes the tile and its command when the panel stops', async () => {
+    const live = await activate();
+    const id = commandId(PROVIDERS[0].descriptor.id, 'launch-here');
+    expect(live.app.commands.hasCommand(id)).toBe(true);
+
+    // The server now reports that assistant's binary gone, which is the same
+    // decision that undocks its panel - there is no second one for the tile.
+    live.setRoster(roster(PROVIDERS[0].descriptor.id));
+    window.dispatchEvent(new Event('online'));
+    await flush();
+
+    expect(live.disposed).toEqual([id]);
+    expect(live.app.commands.hasCommand(id)).toBe(false);
+    expect(live.docked[0].isDisposed).toBe(true);
+    live.docked.forEach(widget => widget.dispose());
+  });
+
+  it('gives an assistant whose binary is absent neither a panel nor a tile', async () => {
+    const absent = PROVIDERS[1].descriptor.id;
+    request.mockImplementation((path: string) =>
+      path === 'status'
+        ? Promise.resolve(roster(absent))
+        : Promise.reject(new Error('no other route'))
+    );
+    const added: any[] = [];
+    const docked: AssistantSessionsPanel[] = [];
+    await (plugin.activate as any)(
+      {
+        serviceManager: { serverSettings: {} },
+        commands: new CommandRegistry(),
+        hasPlugin: () => false
+      } as any,
+      { add: (widget: AssistantSessionsPanel) => docked.push(widget) } as any,
+      null,
+      null,
+      null,
+      null,
+      null,
+      {
+        add: (options: any) => {
+          added.push(options);
+          return { dispose: () => undefined };
+        }
+      } as any
+    );
+    await flush();
+
+    expect(docked.map(widget => widget.node.dataset.provider)).not.toContain(
+      absent
+    );
+    expect(added.map(item => item.command)).not.toContain(
+      commandId(absent, 'launch-here')
+    );
+    expect(added).toHaveLength(PROVIDERS.length - 1);
+    docked.forEach(widget => widget.dispose());
+  });
+
+  it('docks the panels and adds nothing when JupyterLab has no launcher', async () => {
+    // `start` swallows what a provider throws, so "nothing threw" is read off
+    // the line it logs rather than off the activation resolving.
+    const logged = jest
+      .spyOn(console, 'error')
+      .mockImplementation(() => undefined);
+    const live = await activate(false);
+    expect(logged).not.toHaveBeenCalled();
+    logged.mockRestore();
+    expect(live.docked).toHaveLength(PROVIDERS.length);
+    expect(live.added).toEqual([]);
+    // The command is still registered - only the tile depends on the launcher.
+    expect(
+      live.app.commands.hasCommand(
+        commandId(PROVIDERS[0].descriptor.id, 'launch-here')
+      )
+    ).toBe(true);
+    live.docked.forEach(widget => widget.dispose());
+  });
+});