xtralab 0.14.1 → 0.15.1

package/lib/omnibox/recents.js

@@ -1,21 +1,16 @@
 /**
- * Identity of an entry: two uses only match when kind, id and args all do,
- * so runs of one command with different args stay distinct entries.
+ * Identity of an entry: two uses only match when kind, id and args all do, so
+ * runs of one command with different args stay distinct.
  */
 function entryKey(entry) {
     var _a;
     return `${entry.kind}\0${entry.id}\0${JSON.stringify((_a = entry.args) !== null && _a !== void 0 ? _a : null)}`;
 }
-/**
- * State database key the recents list is persisted under.
- */
 const STATE_KEY = 'xtralab:omnibox:recents';
 /**
- * A most-recently-used list of omnibox results, generic over the result kind
- * so commands and files (and future kinds) share one store. Entries are kept
- * most-recent-first, capped at `maxItems` per kind, and persisted through the
- * state database so they survive reloads. Without a state database the list
- * still works for the lifetime of the page.
+ * A most-recently-used list of omnibox results, most-recent-first, capped at
+ * `maxItems` per kind and persisted through the state database. Without a
+ * state database it still works for the lifetime of the page.
  */
 export class OmniboxRecents {
     constructor(options = {}) {
@@ -25,12 +20,14 @@ export class OmniboxRecents {
         this._state = (_a = options.state) !== null && _a !== void 0 ? _a : null;
     }
     /**
-     * Maximum number of entries remembered per kind. Lowering it trims the list
-     * immediately; `0` disables recents entirely.
+     * Maximum entries kept per kind; lowering trims immediately, `0` disables recents.
      */
     get maxItems() {
         return this._maxItems;
     }
+    /**
+     * Set the maximum entries kept per kind.
+     */
     set maxItems(value) {
         const normalized = Math.max(0, Math.floor(value));
         if (normalized === this._maxItems) {
@@ -44,8 +41,7 @@ export class OmniboxRecents {
         }
     }
     /**
-     * The recorded entries, most recent first — all of them, or only those of
-     * one kind.
+     * The recorded entries, most recent first, optionally filtered to one kind.
      */
     entries(kind) {
         return kind
@@ -53,8 +49,7 @@ export class OmniboxRecents {
             : [...this._entries];
     }
     /**
-     * Record a use of `id` (with the args it ran with, if any), moving it to
-     * the front of its kind's list.
+     * Record a use, moving the entry to the front of its kind's list.
      */
     touch(kind, id, args) {
         const entry = args === undefined ? { kind, id } : { kind, id, args };
@@ -65,7 +60,7 @@ export class OmniboxRecents {
     }
     /**
      * Load the persisted list. Entries recorded before the load completes stay
-     * at the front, ahead of the restored history.
+     * ahead of the restored history.
      */
     async restore() {
         if (!this._state) {

package/lib/omnibox/tokens.d.ts

@@ -1,9 +1,8 @@
 import { Token } from '@lumino/coreutils';
 /**
- * A launcher overlay that fuzzy-searches across multiple sources — workspace
- * files, JupyterLab commands — and routes a typed prompt to one of the
- * configured agents. Provided by `xtralab:omnibox` and consumed (optionally)
- * by the top-bar command bar, which opens it on click.
+ * A launcher overlay that fuzzy-searches workspace files and commands and
+ * routes a typed prompt to a configured agent. Provided by `xtralab:omnibox`;
+ * opened by the top-bar command bar.
  */
 export interface IOmnibox {
     /**
@@ -15,13 +14,9 @@ export interface IOmnibox {
      */
     close(): void;
 }
-/**
- * DI token for {@link IOmnibox}. Provided by `xtralab:omnibox`; consumed by
- * `xtralab:command-bar` so the top-bar pill opens the omnibox.
- */
 export declare const IOmnibox: Token<IOmnibox>;
 /**
- * Command id that opens the omnibox (registered by `xtralab:omnibox`). Shared
- * here so the command bar can look up its keybinding and show a shortcut hint.
+ * Command id that opens the omnibox, shared so the command bar can look up
+ * its keybinding for the shortcut hint.
  */
 export declare const OMNIBOX_OPEN_COMMAND = "xtralab:omnibox:open";

package/lib/omnibox/tokens.js

@@ -1,11 +1,7 @@
 import { Token } from '@lumino/coreutils';
-/**
- * DI token for {@link IOmnibox}. Provided by `xtralab:omnibox`; consumed by
- * `xtralab:command-bar` so the top-bar pill opens the omnibox.
- */
 export const IOmnibox = new Token('xtralab:IOmnibox', 'Opens the omnibox overlay that searches files and commands and prompts agents.');
 /**
- * Command id that opens the omnibox (registered by `xtralab:omnibox`). Shared
- * here so the command bar can look up its keybinding and show a shortcut hint.
+ * Command id that opens the omnibox, shared so the command bar can look up
+ * its keybinding for the shortcut hint.
  */
 export const OMNIBOX_OPEN_COMMAND = 'xtralab:omnibox:open';

package/lib/omnibox/widget.d.ts

@@ -6,30 +6,34 @@ import type { CommandPalette } from '@lumino/widgets';
 import type { IAgent } from '../launcher/agents';
 import type { OmniboxRecents } from './recents';
 /**
- * The omnibox overlay widget. Hosts {@link OmniboxComponent} in a React root
- * attached to `document.body`. It carries `jp-ThemedContainer` so JupyterLab's
- * theme CSS variables resolve outside the shell, and its own `jp-xtralab-Omnibox`
- * class for the overlay/panel styling (style/omnibox.css).
+ * The omnibox overlay widget, attached to `document.body`; `jp-ThemedContainer`
+ * makes JupyterLab's theme CSS variables resolve outside the shell.
  */
 export declare class OmniboxWidget extends ReactWidget {
     constructor(options: OmniboxWidget.IOptions);
+    /**
+     * Render the omnibox overlay content.
+     */
     render(): JSX.Element;
     private _options;
 }
-/**
- * A namespace for `OmniboxWidget` statics.
- */
 export declare namespace OmniboxWidget {
     /**
      * Construction options for {@link OmniboxWidget}.
      */
     interface IOptions {
+        /**
+         * The command registry used to look up and execute commands.
+         */
         commands: CommandRegistry;
         /**
          * Snapshot of the command palette's items, read once when the overlay
          * opens; empty when the palette isn't available.
          */
         paletteItems: ReadonlyArray<CommandPalette.IItem>;
+        /**
+         * The document registry used to pick file icons.
+         */
         docRegistry: DocumentRegistry;
         /**
          * Snapshot of the available agents, read once when the overlay opens.

package/lib/omnibox/widget.js

@@ -2,19 +2,13 @@ import { ReactWidget } from '@jupyterlab/ui-components';
 import * as React from 'react';
 import { computeSections } from './model';
 import { loadWorkspaceFiles } from './files';
-/**
- * DOM id of the results listbox, referenced by the input's `aria-controls`.
- */
 const LIST_ID = 'jp-xtralab-Omnibox-list';
-/**
- * Stable DOM id for the result row at `index`, for `aria-activedescendant`.
- */
 function optionId(index) {
     return `jp-xtralab-Omnibox-option-${index}`;
 }
 /**
  * Render `text` with the fuzzy-matched characters at `indices` wrapped in a
- * highlight span, leaving the rest as plain text.
+ * highlight span.
  */
 function renderHighlight(text, indices) {
     if (indices.length === 0) {
@@ -77,19 +71,16 @@ function OmniboxComponent(props) {
         ...sections.agents
     ], [sections]);
     const hasResults = flat.length > 0;
-    // Reset the highlighted row whenever the result set changes, and keep the
-    // index in range when results shrink.
     React.useEffect(() => {
         setActive(current => (current < flat.length ? current : 0));
     }, [flat]);
-    // Keep the highlighted row scrolled into view as it moves.
     React.useEffect(() => {
         var _a, _b;
         (_b = (_a = listRef.current) === null || _a === void 0 ? void 0 : _a.querySelector('.jp-mod-active')) === null || _b === void 0 ? void 0 : _b.scrollIntoView({ block: 'nearest' });
     }, [active, flat]);
     const dismiss = React.useCallback(() => {
-        // Defer so unmounting this React root (via onClose) never happens
-        // synchronously inside the event handler that triggered it.
+        // Defer so unmounting this React root never happens synchronously inside
+        // the event handler that triggered it.
         window.setTimeout(onClose, 0);
     }, [onClose]);
     const run = React.useCallback((item) => {
@@ -162,10 +153,8 @@ function OmniboxComponent(props) {
                 : trans.__('Search files and commands, or type a prompt and pick an agent. Prefix with > for commands or / for files.')))))));
 }
 /**
- * The omnibox overlay widget. Hosts {@link OmniboxComponent} in a React root
- * attached to `document.body`. It carries `jp-ThemedContainer` so JupyterLab's
- * theme CSS variables resolve outside the shell, and its own `jp-xtralab-Omnibox`
- * class for the overlay/panel styling (style/omnibox.css).
+ * The omnibox overlay widget, attached to `document.body`; `jp-ThemedContainer`
+ * makes JupyterLab's theme CSS variables resolve outside the shell.
  */
 export class OmniboxWidget extends ReactWidget {
     constructor(options) {
@@ -175,6 +164,9 @@ export class OmniboxWidget extends ReactWidget {
         this.addClass('jp-xtralab-Omnibox');
         this.addClass('jp-ThemedContainer');
     }
+    /**
+     * Render the omnibox overlay content.
+     */
     render() {
         return React.createElement(OmniboxComponent, { ...this._options });
     }

package/lib/searchReplace/index.d.ts

@@ -1,25 +1,9 @@
 import { JupyterFrontEndPlugin } from '@jupyterlab/application';
 /**
- * Bind Accel+Shift+F (Cmd+Shift+F on macOS, Ctrl+Shift+F elsewhere) to the
- * project-wide Search and Replace panel, matching the equivalent shortcut in
- * editors like VS Code.
- *
- * Two pieces are needed because that chord is already taken: JupyterLab core
- * binds Accel+Shift+F to `filebrowser:toggle-main`.
- *
- * 1. The chord is freed declaratively. `SettingRegistry.reconcileShortcuts`
- *    keys collisions and disables on (keys, selector) — not on command — so the
- *    `@jupyterlab/shortcuts-extension:shortcuts` override in
- *    `default_setting_overrides.d/00-xtralab.json` disables the file-browser
- *    binding. The file browser stays reachable from its sidebar tab and the
- *    View menu; only the keyboard shortcut moves.
- *
- * 2. The new binding is added imperatively below rather than as another shipped
- *    default. A `disabled` default and a re-binding default land on the same
- *    (keys, selector) slot, and the disable suppresses every default on that
- *    slot — including the re-binding. `commands.addKeyBinding` runs outside the
- *    reconcile pass, so it is unaffected and wins cleanly once the file-browser
- *    binding is gone.
+ * Bind Accel+Shift+F to the Search and Replace panel (VS Code parity). Core
+ * binds the chord to `filebrowser:toggle-main`; a `default_setting_overrides.d`
+ * override disables it. The re-binding is imperative: `reconcileShortcuts` keys
+ * on (keys, selector), so the disable would suppress a shipped default too.
  */
 declare const plugin: JupyterFrontEndPlugin<void>;
 export default plugin;

package/lib/searchReplace/index.js

@@ -4,33 +4,15 @@ import { ITranslator, nullTranslator } from '@jupyterlab/translation';
 const PLUGIN_ID = 'xtralab:search-replace';
 const COMMAND_ID = 'xtralab:activate-search-replace';
 /**
- * Widget id of the panel contributed by `jupyterlab-search-replace`. The
- * extension adds it to the left sidebar but registers no command of its own,
- * so there is nothing to bind a shortcut to out of the box — this plugin adds
- * the missing command.
+ * Widget id of the `jupyterlab-search-replace` left-sidebar panel; the
+ * extension registers no command of its own to bind a shortcut to.
  */
 const SEARCH_REPLACE_WIDGET_ID = 'jp-search-replace';
 /**
- * Bind Accel+Shift+F (Cmd+Shift+F on macOS, Ctrl+Shift+F elsewhere) to the
- * project-wide Search and Replace panel, matching the equivalent shortcut in
- * editors like VS Code.
- *
- * Two pieces are needed because that chord is already taken: JupyterLab core
- * binds Accel+Shift+F to `filebrowser:toggle-main`.
- *
- * 1. The chord is freed declaratively. `SettingRegistry.reconcileShortcuts`
- *    keys collisions and disables on (keys, selector) — not on command — so the
- *    `@jupyterlab/shortcuts-extension:shortcuts` override in
- *    `default_setting_overrides.d/00-xtralab.json` disables the file-browser
- *    binding. The file browser stays reachable from its sidebar tab and the
- *    View menu; only the keyboard shortcut moves.
- *
- * 2. The new binding is added imperatively below rather than as another shipped
- *    default. A `disabled` default and a re-binding default land on the same
- *    (keys, selector) slot, and the disable suppresses every default on that
- *    slot — including the re-binding. `commands.addKeyBinding` runs outside the
- *    reconcile pass, so it is unaffected and wins cleanly once the file-browser
- *    binding is gone.
+ * Bind Accel+Shift+F to the Search and Replace panel (VS Code parity). Core
+ * binds the chord to `filebrowser:toggle-main`; a `default_setting_overrides.d`
+ * override disables it. The re-binding is imperative: `reconcileShortcuts` keys
+ * on (keys, selector), so the disable would suppress a shipped default too.
  */
 const plugin = {
     id: PLUGIN_ID,
@@ -45,9 +27,7 @@ const plugin = {
             label: trans.__('Search and Replace'),
             caption: trans.__('Show the Search and Replace panel'),
             execute: () => {
-                // `activateById` expands the left sidebar when collapsed, selects the
-                // tab, and the widget focuses its search input from `onAfterShow`, so
-                // the user can start typing a query immediately. It no-ops if
+                // The widget focuses its search input from `onAfterShow`; no-ops if
                 // `jupyterlab-search-replace` is unavailable.
                 labShell.activateById(SEARCH_REPLACE_WIDGET_ID);
             }

package/lib/showOutput/index.d.ts

@@ -1,17 +1,8 @@
 import { JupyterFrontEndPlugin } from '@jupyterlab/application';
 /**
- * Contribute `xtralab:show`: render a single MIME bundle into a main-area
- * panel using the application's render-mime registry.
- *
- * This is the kernel-free counterpart to running a notebook. A coding agent
- * generates the content itself (a Vega-Lite spec, a Markdown explainer, an
- * HTML fragment, an SVG, a base64 image) and hands it to this command, which
- * renders it with the same renderers JupyterLab uses for cell output and docks
- * the result beside the code. Nothing is written to disk and no kernel is
- * required, so it works even where the kernel has no plotting libraries.
- *
- * Repeated calls with the same `id` reuse one panel, so a walkthrough can
- * refresh the view in place instead of piling up tabs.
+ * Contributes `xtralab:show`: render a single MIME bundle into a panel with
+ * the same renderers JupyterLab uses for cell output — no kernel, no file on
+ * disk. Repeated calls with the same `id` reuse one panel.
  */
 declare const plugin: JupyterFrontEndPlugin<void>;
 export default plugin;

package/lib/showOutput/index.js

@@ -5,23 +5,11 @@ import { ITranslator, nullTranslator } from '@jupyterlab/translation';
 import { Panel } from '@lumino/widgets';
 import { coerceData } from '../mimeData';
 const PLUGIN_ID = 'xtralab:show-output';
-/**
- * Render arbitrary rich content into a panel, with no notebook and no kernel.
- */
 const SHOW_COMMAND = 'xtralab:show';
 /**
- * Contribute `xtralab:show`: render a single MIME bundle into a main-area
- * panel using the application's render-mime registry.
- *
- * This is the kernel-free counterpart to running a notebook. A coding agent
- * generates the content itself (a Vega-Lite spec, a Markdown explainer, an
- * HTML fragment, an SVG, a base64 image) and hands it to this command, which
- * renders it with the same renderers JupyterLab uses for cell output and docks
- * the result beside the code. Nothing is written to disk and no kernel is
- * required, so it works even where the kernel has no plotting libraries.
- *
- * Repeated calls with the same `id` reuse one panel, so a walkthrough can
- * refresh the view in place instead of piling up tabs.
+ * Contributes `xtralab:show`: render a single MIME bundle into a panel with
+ * the same renderers JupyterLab uses for cell output — no kernel, no file on
+ * disk. Repeated calls with the same `id` reuse one panel.
  */
 const plugin = {
     id: PLUGIN_ID,
@@ -32,7 +20,6 @@ const plugin = {
     activate: (app, rendermime, labShell, palette, translator) => {
         const { commands } = app;
         const trans = (translator !== null && translator !== void 0 ? translator : nullTranslator).load('jupyterlab');
-        // One reusable panel per `id`, so repeated shows refresh in place.
         const panels = new Map();
         commands.addCommand(SHOW_COMMAND, {
             label: trans.__('Show Rich Output'),
@@ -89,16 +76,14 @@ const plugin = {
                 }
                 const model = rendermime.createModel({ data: bundle, trusted: true });
                 const renderer = rendermime.createRenderer(chosen);
-                // A scrollable Panel, not a MainAreaWidget: MainAreaWidget does not lay
-                // out its content in the side area, and the panel needs to scroll when
-                // the content is taller than it (style/showOutput.css).
+                // Not a MainAreaWidget: it does not lay out its content in the side
+                // area; the panel scrolls via style/showOutput.css.
                 const widget = new Panel();
                 widget.addClass('jp-xtralab-ShowPanel');
                 widget.id = `xtralab-show-${id}`;
                 widget.title.label = label;
                 widget.title.closable = true;
                 widget.addWidget(renderer);
-                // Replace any existing panel with this id so shows refresh in place.
                 const existing = panels.get(id);
                 if (existing && !existing.isDisposed) {
                     existing.dispose();
@@ -110,8 +95,7 @@ const plugin = {
                     }
                 });
                 // Attach before rendering so renderers that need layout (Vega) size
-                // correctly. Default to the side area so the editor keeps full width;
-                // only split the document area when `area` is "main".
+                // correctly.
                 if (area === 'main') {
                     labShell.add(widget, 'main', {
                         mode,

package/lib/sidebar/index.d.ts

@@ -1,18 +1,9 @@
 import { JupyterFrontEndPlugin } from '@jupyterlab/application';
 /**
- * Lets the user toggle individual left-sidebar tabs from
- * View > Appearance > Left Sidebar. Removing a widget from a `LabShell`
- * side area is done by setting `widget.parent = null`: the StackedPanel
- * emits `widgetRemoved`, which the SideBarHandler responds to by removing
- * the matching tab. The widget instance is preserved, so we can re-add it
- * later via `labShell.add` with its original rank.
- *
- * The menu placement is contributed declaratively in
- * `schema/sidebar.json`, so this plugin only registers commands and
- * applies state — it does not touch `IMainMenu` directly.
- *
- * The preference is persisted to `xtralab:sidebar` settings so the choice
- * survives reloads.
+ * Toggles individual sidebar tabs from View > Appearance > Sidebars. Hiding
+ * detaches the widget while keeping the instance for a later re-add; which
+ * side it came from is only tracked in-memory, so after a reload a re-shown
+ * tab lands on the left. Menu placement is declared in schema/sidebar.json.
  */
 declare const plugin: JupyterFrontEndPlugin<void>;
 export default plugin;

package/lib/sidebar/index.js

@@ -3,6 +3,27 @@ import { ISettingRegistry } from '@jupyterlab/settingregistry';
 import { ITranslator, nullTranslator } from '@jupyterlab/translation';
 const PLUGIN_ID = 'xtralab:sidebar';
 const TARGETS = [
+    {
+        id: 'xtralab-running-terminals',
+        rank: 1,
+        settingKey: 'showTerminals',
+        command: 'xtralab:toggle-terminals',
+        label: trans => trans.__('Terminals')
+    },
+    {
+        id: 'xtralab:file-browser',
+        rank: 2,
+        settingKey: 'showFileBrowser',
+        command: 'xtralab:toggle-file-browser',
+        label: trans => trans.__('File Browser')
+    },
+    {
+        id: 'jp-git-sessions',
+        rank: 200,
+        settingKey: 'showGitPanel',
+        command: 'xtralab:toggle-git-panel',
+        label: trans => trans.__('Git')
+    },
     {
         id: 'filebrowser',
         rank: 100,
@@ -16,55 +37,56 @@ const TARGETS = [
         settingKey: 'showRunningSessions',
         command: 'xtralab:toggle-running-sessions',
         label: trans => trans.__('Running Terminals and Kernels')
+    },
+    {
+        id: 'jp-search-replace',
+        rank: 900,
+        settingKey: 'showSearchReplace',
+        command: 'xtralab:toggle-search-replace',
+        label: trans => trans.__('Search and Replace')
     }
 ];
 /**
- * Lets the user toggle individual left-sidebar tabs from
- * View > Appearance > Left Sidebar. Removing a widget from a `LabShell`
- * side area is done by setting `widget.parent = null`: the StackedPanel
- * emits `widgetRemoved`, which the SideBarHandler responds to by removing
- * the matching tab. The widget instance is preserved, so we can re-add it
- * later via `labShell.add` with its original rank.
- *
- * The menu placement is contributed declaratively in
- * `schema/sidebar.json`, so this plugin only registers commands and
- * applies state — it does not touch `IMainMenu` directly.
- *
- * The preference is persisted to `xtralab:sidebar` settings so the choice
- * survives reloads.
+ * Toggles individual sidebar tabs from View > Appearance > Sidebars. Hiding
+ * detaches the widget while keeping the instance for a later re-add; which
+ * side it came from is only tracked in-memory, so after a reload a re-shown
+ * tab lands on the left. Menu placement is declared in schema/sidebar.json.
  */
 const plugin = {
     id: PLUGIN_ID,
-    description: 'Toggle visibility of selected sidebar tabs (default file browser, running sessions) from the View menu.',
+    description: 'Toggle visibility of individual sidebar tabs from the View menu.',
     autoStart: true,
     requires: [ILabShell],
     optional: [ISettingRegistry, ITranslator],
     activate: async (app, labShell, settingRegistry, translator) => {
         const trans = (translator !== null && translator !== void 0 ? translator : nullTranslator).load('jupyterlab');
         const { commands } = app;
-        // Cache widget instances so we can re-add them after `widget.parent =
-        // null` has detached them from the sidebar. The widget is no longer
-        // reachable through `labShell.widgets('left')` once removed, so a
-        // missing cache entry would leave us unable to bring the tab back.
+        // Detached widgets are unreachable via `labShell.widgets(...)`; keep
+        // instances here so hidden tabs can be re-added.
         const widgetCache = new Map();
-        const findInSidebar = (id) => {
-            for (const w of labShell.widgets('left')) {
-                if (w.id === id) {
-                    return w;
+        const hiddenFrom = new Map();
+        const findInSidebars = (id) => {
+            for (const area of ['left', 'right']) {
+                for (const widget of labShell.widgets(area)) {
+                    if (widget.id === id) {
+                        return { widget, area };
+                    }
                 }
             }
             return null;
         };
+        const locate = (id) => { var _a, _b; return (_b = (_a = findInSidebars(id)) === null || _a === void 0 ? void 0 : _a.area) !== null && _b !== void 0 ? _b : null; };
         const captureWidget = (id) => {
+            var _a;
             const cached = widgetCache.get(id);
             if (cached && !cached.isDisposed) {
                 return cached;
             }
-            const found = findInSidebar(id);
+            const found = findInSidebars(id);
             if (found) {
-                widgetCache.set(id, found);
+                widgetCache.set(id, found.widget);
             }
-            return found;
+            return (_a = found === null || found === void 0 ? void 0 : found.widget) !== null && _a !== void 0 ? _a : null;
         };
         let settings = null;
         const readPreference = (target) => {
@@ -75,22 +97,27 @@ const plugin = {
             return typeof value === 'boolean' ? value : true;
         };
         const apply = (target) => {
+            var _a;
             const widget = captureWidget(target.id);
             if (!widget) {
-                // The upstream widget hasn't been added yet (or the extension is
-                // disabled). Nothing to do — the next time `apply` runs and finds
-                // it, the preference will take effect.
                 return;
             }
-            const present = findInSidebar(target.id) !== null;
+            const area = locate(target.id);
+            if (!area && widget.parent !== null) {
+                // Attached outside the sidebars — leave it alone.
+                return;
+            }
             const wantPresent = readPreference(target);
-            if (wantPresent && !present) {
-                labShell.add(widget, 'left', { rank: target.rank });
+            if (wantPresent && !area) {
+                labShell.add(widget, (_a = hiddenFrom.get(target.id)) !== null && _a !== void 0 ? _a : 'left', {
+                    rank: target.rank
+                });
+                hiddenFrom.delete(target.id);
             }
-            else if (!wantPresent && present) {
-                // Setting `parent = null` triggers SideBarHandler's
-                // `_onWidgetRemoved`, which strips the tab while leaving the
-                // widget instance alive for a later re-add.
+            else if (!wantPresent && area) {
+                hiddenFrom.set(target.id, area);
+                // Detaching makes the SideBarHandler remove the tab while the
+                // widget instance stays alive for a later re-add.
                 widget.parent = null;
             }
         };
@@ -103,23 +130,26 @@ const plugin = {
             commands.addCommand(target.command, {
                 label: target.label(trans),
                 isToggled: () => readPreference(target),
+                isVisible: () => {
+                    // List only tabs this plugin can manage: in a sidebar, or
+                    // hidden by this plugin (`parent === null`).
+                    const widget = captureWidget(target.id);
+                    return (widget !== null &&
+                        (widget.parent === null || locate(target.id) !== null));
+                },
                 execute: async () => {
                     const next = !readPreference(target);
                     if (settings) {
                         try {
                             await settings.set(target.settingKey, next);
-                            // `settings.changed` will fire and drive `apply` + the
-                            // command-state refresh. Returning here keeps the toggle's
-                            // single source of truth in the settings registry.
+                            // `settings.changed` drives `apply` and the state refresh.
                             return;
                         }
                         catch (reason) {
                             console.error(`xtralab: failed to persist ${target.settingKey}`, reason);
                         }
                     }
-                    // No settings registry available (or the write failed): fall
-                    // back to applying the change in-memory so the toggle still
-                    // works for the current session.
+                    // No settings (or the write failed): apply in-memory for this session.
                     apply(target);
                     commands.notifyCommandChanged(target.command);
                 }
@@ -140,11 +170,8 @@ const plugin = {
             }
         }
         void app.restored.then(() => {
-            // Capture references first so a hidden-on-startup widget is still
-            // recoverable later. `apply` would also do the lookup, but only on
-            // the targets that need to stay visible — by capturing every target
-            // here we keep the cache populated for both directions of the
-            // toggle.
+            // Capture every widget before applying, so tabs hidden on startup
+            // stay recoverable.
             for (const target of TARGETS) {
                 captureWidget(target.id);
             }

package/lib/terminalNotifications/index.d.ts

@@ -1,15 +1,9 @@
 import { JupyterFrontEndPlugin } from '@jupyterlab/application';
 /**
- * Turns the notifications coding agents already emit (OSC 9, OSC 777, the bell)
- * into desktop notifications. JupyterLab's xterm renders these sequences but
- * never forwards them to the OS, so this plugin hooks each terminal and bridges
- * them through `window.xtralab.notify` (desktop) or the web Notifications API.
- *
- * A notification is suppressed while its terminal is the focused, active tab,
- * and throttled per terminal. The desktop shell advertises
- * `TERM_PROGRAM=iTerm.app` so agents emit OSC 9 in the first place, and the
- * session name is forwarded so clicking a notification focuses the terminal
- * that fired it.
+ * Turns the OSC 9 / OSC 777 / bell sequences agents emit into desktop
+ * notifications via `window.xtralab.notify` (desktop) or the web Notifications
+ * API — JupyterLab's xterm renders them but never forwards them to the OS.
+ * The desktop shell advertises `TERM_PROGRAM=iTerm.app` so agents emit OSC 9.
  */
 declare const plugin: JupyterFrontEndPlugin<void>;
 export default plugin;