xtralab 0.14.1 → 0.15.0

package/lib/fileBrowser/widget.js

@@ -1,23 +1,28 @@
 import * as React from 'react';
-import { ReactWidget, Toolbar } from '@jupyterlab/ui-components';
+import { AccordionToolbar, PanelWithToolbar, ReactWidget, Toolbar } from '@jupyterlab/ui-components';
 import { Signal } from '@lumino/signaling';
-import { PanelLayout, Widget } from '@lumino/widgets';
+import { AccordionPanel, PanelLayout, Widget } from '@lumino/widgets';
 import { FileBrowserComponent } from './fileBrowser';
 import { xtralabFileBrowserIcon } from './icons';
 export const FILE_BROWSER_ID = 'xtralab:file-browser';
 /**
- * The CSS class added to the xtralab file browser widget. The selectors that
- * bind application context menu items hang off this class, so it must remain
- * specific enough not to clash with other browsers (such as the default
- * `jp-FileBrowser`).
+ * Persisted by the movable-sections plugin, so it must stay stable.
+ */
+const TREE_SECTION_ID = 'xtralab-file-tree-section';
+/**
+ * Context menu selectors hang off this class, so it sits on the section and
+ * keeps matching once the tree moves to another panel.
  */
 const FILE_BROWSER_CSS_CLASS = 'jp-xtralab-FileBrowser';
+const PANEL_CSS_CLASS = 'jp-xtralab-FileBrowserPanel';
 const TOOLBAR_CSS_CLASS = 'jp-xtralab-FileBrowser-toolbar';
 const CONTENT_CSS_CLASS = 'jp-xtralab-FileBrowser-content';
+const ACCORDION_CSS_CLASS = 'jp-xtralab-FileBrowser-accordion';
+const MOVABLE_SECTION_CLASS = 'jp-movable-section';
 /**
- * Lumino widget that hosts the React-based `@pierre/trees` file browser.
- * The widget is laid out with a JupyterLab `Toolbar` on top and the tree
- * filling the remaining space.
+ * Lumino widget hosting the React-based `@pierre/trees` file browser. The tree
+ * and its toolbar form one movable "Files" section, and sections from other
+ * panels can be moved in below it.
  */
 export class XtralabFileBrowser extends Widget {
     constructor(options) {
@@ -31,26 +36,37 @@ export class XtralabFileBrowser extends Widget {
         this._collapseAllRequested = new Signal(this);
         this._fileFilterVisible = false;
         this._fileFilterVisibleChanged = new Signal(this);
-        const layout = (this.layout = new PanelLayout());
+        this._accordion = null;
+        this._contentChanged = new Signal(this);
+        this._sectionAdded = new Signal(this);
+        const layout = (this._panelLayout = this.layout = new PanelLayout());
         this._contentsManager = options.contentsManager;
         this._docManager = options.docManager;
         this._onOpenFile = options.onOpenFile;
+        this._translator = options.translator;
         this.id = FILE_BROWSER_ID;
         this.title.icon = xtralabFileBrowserIcon;
         this.title.caption = 'xtralab File Browser';
-        this.addClass(FILE_BROWSER_CSS_CLASS);
+        this.addClass(PANEL_CSS_CLASS);
         this._toolbar = new Toolbar();
         this._toolbar.addClass(TOOLBAR_CSS_CLASS);
         this._toolbar.node.setAttribute('aria-label', 'file browser');
-        layout.addWidget(this._toolbar);
         this._content = new XtralabFileTreeContent({
             contentsManager: this._contentsManager,
             docManager: this._docManager,
             onOpenFile: this._onOpenFile,
+            translator: this._translator,
             browser: this
         });
         this._content.addClass(CONTENT_CSS_CLASS);
-        layout.addWidget(this._content);
+        this._section = new PanelWithToolbar({ toolbar: this._toolbar });
+        this._section.id = TREE_SECTION_ID;
+        // Only an accordion host draws this; a plain `PanelLayout` shows no title.
+        this._section.title.label = 'Files';
+        this._section.addClass(FILE_BROWSER_CSS_CLASS);
+        this._section.addWidget(this._toolbar);
+        this._section.addWidget(this._content);
+        layout.addWidget(this._section);
     }
     get contentsManager() {
         return this._contentsManager;
@@ -121,6 +137,129 @@ export class XtralabFileBrowser extends Widget {
     toggleFileFilter() {
         this.setFileFilterVisible(!this._fileFilterVisible);
     }
+    get sectionNode() {
+        return this._section.node;
+    }
+    get isEmpty() {
+        return this._panelLayout.widgets.length === 0;
+    }
+    get contentChanged() {
+        return this._contentChanged;
+    }
+    get sectionAdded() {
+        return this._sectionAdded;
+    }
+    get accordionPanel() {
+        return this._accordion;
+    }
+    get sections() {
+        if (!this._accordion) {
+            return [];
+        }
+        return this._accordion.widgets.filter(w => w !== this._section);
+    }
+    /**
+     * The toolbar is the section's title node: it is the tree's header row at
+     * home, and an accordion host renders it inside the section title.
+     */
+    getSections() {
+        return this._isSectionHome()
+            ? [
+                {
+                    id: TREE_SECTION_ID,
+                    titleNode: this._toolbar.node,
+                    widget: this._section
+                }
+            ]
+            : [];
+    }
+    removeSectionById(sectionId) {
+        if (sectionId !== TREE_SECTION_ID || !this._isSectionHome()) {
+            return null;
+        }
+        this._section.parent = null;
+        if (this._accordion && this._accordion.widgets.length === 0) {
+            this._accordion.dispose();
+            this._accordion = null;
+        }
+        // Away from home the toolbar must not offer "Move to …" as well;
+        // `getSections` re-marks it on the way back.
+        this._toolbar.node.classList.remove(MOVABLE_SECTION_CLASS);
+        this._contentChanged.emit();
+        return this._section;
+    }
+    reinsertSection(widget) {
+        if (this._accordion) {
+            this._accordion.insertWidget(0, widget);
+        }
+        else {
+            this._panelLayout.addWidget(widget);
+            this._restoreToolbar();
+        }
+        this._contentChanged.emit();
+    }
+    /**
+     * The move plugin reconciles persisted moves only against sections announced
+     * after `registerSource`, and this panel builds its section in the constructor.
+     */
+    announceSections() {
+        for (const entry of this.getSections()) {
+            this._sectionAdded.emit(entry);
+        }
+    }
+    /**
+     * The first hosted section moves the tree into an accordion.
+     */
+    addSection(widget) {
+        if (!this._accordion) {
+            const accordion = new AccordionPanel({
+                layout: AccordionToolbar.createLayout({})
+            });
+            accordion.addClass(ACCORDION_CSS_CLASS);
+            if (this._section.parent === this) {
+                accordion.addWidget(this._section);
+            }
+            accordion.addWidget(widget);
+            this._accordion = accordion;
+            this._panelLayout.addWidget(accordion);
+        }
+        else {
+            this._accordion.addWidget(widget);
+        }
+        this._contentChanged.emit();
+    }
+    removeSectionWidget(widget) {
+        if (!this._accordion || widget.parent !== this._accordion) {
+            return;
+        }
+        widget.parent = null;
+        const remaining = this._accordion.widgets;
+        const treeOnly = remaining.length === 1 && remaining[0] === this._section;
+        if (treeOnly || remaining.length === 0) {
+            if (treeOnly) {
+                if (this._section.isHidden) {
+                    this._section.show();
+                }
+                this._panelLayout.addWidget(this._section);
+                this._restoreToolbar();
+            }
+            this._accordion.dispose();
+            this._accordion = null;
+        }
+        this._contentChanged.emit();
+    }
+    _isSectionHome() {
+        const parent = this._section.parent;
+        return parent === this || (!!this._accordion && parent === this._accordion);
+    }
+    /**
+     * An accordion host moves the toolbar node into the section title and leaves
+     * it orphaned on detach; re-parenting makes the layout attach it again.
+     */
+    _restoreToolbar() {
+        this._toolbar.parent = null;
+        this._section.insertWidget(0, this._toolbar);
+    }
 }
 /**
  * The React-rendered region of the file browser. Lives inside the host
@@ -132,6 +271,6 @@ class XtralabFileTreeContent extends ReactWidget {
         this._options = options;
     }
     render() {
-        return (React.createElement(FileBrowserComponent, { contentsManager: this._options.contentsManager, docManager: this._options.docManager, onOpenFile: this._options.onOpenFile, widget: this._options.browser }));
+        return (React.createElement(FileBrowserComponent, { contentsManager: this._options.contentsManager, docManager: this._options.docManager, onOpenFile: this._options.onOpenFile, translator: this._options.translator, widget: this._options.browser }));
     }
 }

package/lib/index.js

@@ -2,6 +2,7 @@ import aboutPlugin from './about';
 import agentSessionsPlugin from './agentSessions';
 import askAgentPlugin from './askAgent';
 import commandBarPlugin from './commandBar';
+import customPanelPlugin from './customPanel';
 import fileBrowserPlugin from './fileBrowser';
 import fileTypeIconsPlugin from './fileTypeIcons';
 import editorBreadcrumbsPlugin from './editorBreadcrumbs';
@@ -33,6 +34,7 @@ const plugins = [
     agentSessionsPlugin,
     askAgentPlugin,
     commandBarPlugin,
+    customPanelPlugin,
     editorBreadcrumbsPlugin,
     editorIndentPlugin,
     fileBrowserPlugin,

package/lib/launcher/agents.d.ts

@@ -23,7 +23,7 @@ export interface IAgent {
      * the user types one into the launcher's prompt box. The semantics:
      *
      *   - `[]` → prompt is appended as a positional argument:
-     *     `<command> 'PROMPT'`. (Used by claude, codex, vibe.)
+     *     `<command> 'PROMPT'`. (Used by claude, codex, vibe, pi.)
      *   - `['-i']` / `['--prompt']` → the prompt is preceded by a flag:
      *     `<command> -i 'PROMPT'`. (Used by copilot, opencode.)
      *   - `undefined` → the agent does not accept an initial prompt. The

package/lib/launcher/agents.js

@@ -7,8 +7,9 @@ import { BUILTIN_AGENT_ICONS } from './icons';
  * icons come from), but use the bare CLI names a user would type in a
  * terminal rather than the ACP wrapper binaries that project spawns.
  * Antigravity (Google's agent-first IDE/CLI, `agy`) is the Google agent.
- * Anything not on the user's `$PATH` is filtered out at activation time, so
- * the wider list is harmless.
+ * Pi (https://pi.dev, `earendil-works/pi`) is a minimal extensible coding
+ * agent; its mark comes straight from its site. Anything not on the user's
+ * `$PATH` is filtered out at activation time, so the wider list is harmless.
  */
 const DEFAULTS = [
     {
@@ -100,6 +101,18 @@ const DEFAULTS = [
         rank: 7,
         requireAvailable: true,
         promptArgs: []
+    },
+    {
+        id: 'pi',
+        label: 'Pi',
+        caption: 'Start Pi in a new terminal.',
+        command: 'pi',
+        icon: BUILTIN_AGENT_ICONS.pi,
+        rank: 8,
+        requireAvailable: true,
+        // `pi [messages...]` starts the interactive TUI and sends the messages
+        // as the first user prompt, so the positional form applies.
+        promptArgs: []
     }
 ];
 /**

package/lib/launcher/icons.js

@@ -5,11 +5,14 @@ import { LabIcon } from '@jupyterlab/ui-components';
  * (`jupyter_ai_acp_client/static/*.svg`, BSD-3-Clause); Antigravity post-dates
  * that set, so its mark is the official glyph from `@lobehub/icons-static-svg`
  * (MIT) — we ship the brand-colored `antigravity-color` variant so Antigravity
- * reads as a multi-color Google mark. Small adjustments are applied
+ * reads as a multi-color Google mark. Pi's mark is the official `logo-auto.svg`
+ * from https://pi.dev (MIT, `earendil-works/pi`). Small adjustments are applied
  * to play nicely with JupyterLab themes:
- *   - Monochrome marks (Codex, Copilot, Goose) use `currentColor` so they
+ *   - Monochrome marks (Codex, Copilot, Goose, Pi) use `currentColor` so they
  *     inherit the surrounding launcher card's text color rather than
- *     hard-coding black, which disappears on the dark theme.
+ *     hard-coding black, which disappears on the dark theme. For Pi this
+ *     replaces the upstream `prefers-color-scheme` style block, which follows
+ *     the OS scheme rather than the active JupyterLab theme.
  *   - The Goose mark upstream is rendered on a white rounded rect; we drop
  *     the rect so the silhouette can sit on the launcher card directly.
  *   - SVG ids that would collide if two copies of the same artwork ended up
@@ -169,6 +172,13 @@ const opencodeIcon = new LabIcon({
   <path fill-rule="evenodd" clip-rule="evenodd" d="M384 416H128V96H384V416ZM320 160H192V352H320V160Z" fill="white"/>
 </svg>`
 });
+const piIcon = new LabIcon({
+    name: 'xtralab:agent-pi',
+    svgstr: `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 800 800" fill="currentColor">
+  <path fill-rule="evenodd" d="M165.29 165.29H517.36V400H400V517.36H282.65V634.72H165.29ZM282.65 282.65V400H400V282.65Z"/>
+  <path d="M517.36 400H634.72V634.72H517.36Z"/>
+</svg>`
+});
 const neovimIcon = new LabIcon({
     name: 'xtralab:editor-neovim',
     svgstr: `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="#57A143">
@@ -195,7 +205,8 @@ export const BUILTIN_AGENT_ICONS = {
     goose: gooseIcon,
     kiro: kiroIcon,
     'mistral-vibe': mistralVibeIcon,
-    opencode: opencodeIcon
+    opencode: opencodeIcon,
+    pi: piIcon
 };
 /**
  * Built-in icons keyed by the editor's id, used to resolve the icon for a

package/lib/launcher/schemaDefaults.d.ts

@@ -4,14 +4,7 @@ import type { ISettingRegistry } from '@jupyterlab/settingregistry';
  */
 export declare const LAUNCHER_PLUGIN_ID = "xtralab:launcher";
 /**
- * Register a `fetch` transform that injects xtralab's built-in agent and
- * editor lists as the schema defaults for the `xtralab:launcher` settings, so
- * the Settings Editor shows the shipped list.
- *
- * The schema declares `jupyter.lab.transform: true`, so the registry defers
- * loading the plugin until a transform is registered: callers must invoke this
- * before their first `settingRegistry.load(LAUNCHER_PLUGIN_ID)`. Idempotent, so
- * the two plugins that load these settings can both call it regardless of
- * activation order.
+ * Must run before the first `load(LAUNCHER_PLUGIN_ID)` (the schema sets
+ * `jupyter.lab.transform: true`); idempotent across callers.
  */
 export declare function registerLauncherSchemaDefaults(settingRegistry: ISettingRegistry): void;

package/lib/launcher/schemaDefaults.js

@@ -5,20 +5,38 @@ import { defaultEditorSettings } from './editors';
  */
 export const LAUNCHER_PLUGIN_ID = 'xtralab:launcher';
 /**
- * Setting registries that already have the transform, so both callers skip
- * re-registering (the registry rejects a duplicate transformer).
+ * Registries that already have the transform (duplicates are rejected).
  */
 const registered = new WeakSet();
 /**
- * Register a `fetch` transform that injects xtralab's built-in agent and
- * editor lists as the schema defaults for the `xtralab:launcher` settings, so
- * the Settings Editor shows the shipped list.
- *
- * The schema declares `jupyter.lab.transform: true`, so the registry defers
- * loading the plugin until a transform is registered: callers must invoke this
- * before their first `settingRegistry.load(LAUNCHER_PLUGIN_ID)`. Idempotent, so
- * the two plugins that load these settings can both call it regardless of
- * activation order.
+ * Merge sparse user entries over the built-in defaults, keyed by `id`.
+ */
+function mergeSettingsById(defaults, user) {
+    const entries = Array.isArray(user) ? user : [];
+    const overrideById = new Map(entries.map(entry => [entry.id, entry]));
+    const merged = defaults.map(base => {
+        const override = overrideById.get(base.id);
+        if (!override) {
+            return base;
+        }
+        overrideById.delete(base.id);
+        return { ...base, ...override };
+    });
+    merged.push(...overrideById.values());
+    // Item schema defaults are applied before this transform runs; without the
+    // refill, sparse entries render with unchecked boxes.
+    return merged.map(entry => {
+        var _a, _b;
+        return ({
+            ...entry,
+            enabled: (_a = entry.enabled) !== null && _a !== void 0 ? _a : true,
+            requireAvailable: (_b = entry.requireAvailable) !== null && _b !== void 0 ? _b : true
+        });
+    });
+}
+/**
+ * Must run before the first `load(LAUNCHER_PLUGIN_ID)` (the schema sets
+ * `jupyter.lab.transform: true`); idempotent across callers.
  */
 export function registerLauncherSchemaDefaults(settingRegistry) {
     if (registered.has(settingRegistry)) {
@@ -26,11 +44,17 @@ export function registerLauncherSchemaDefaults(settingRegistry) {
     }
     registered.add(settingRegistry);
     settingRegistry.transform(LAUNCHER_PLUGIN_ID, {
+        compose: plugin => {
+            const { user } = plugin.data;
+            const composite = { ...plugin.data.composite };
+            composite.agents = mergeSettingsById(defaultAgentSettings(), user.agents);
+            composite.editors = mergeSettingsById(defaultEditorSettings(), user.editors);
+            plugin.data = { composite, user };
+            return plugin;
+        },
         fetch: plugin => {
             const properties = plugin.schema.properties;
             if (properties) {
-                // The settings shapes are plain JSON by construction, but their named
-                // interfaces lack an index signature, so cast at this TS→JSON boundary.
                 if (properties.agents) {
                     properties.agents.default =
                         defaultAgentSettings();

package/lib/sidebar/index.d.ts

@@ -1,18 +1,12 @@
 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,
+ * whichever side a tab currently lives on. Hiding detaches the widget
+ * (`widget.parent = null`) while keeping the instance for a later
+ * re-add; the preference persists in this plugin's settings. Which side
+ * a hidden tab came from is only tracked in-memory, so after a reload a
+ * re-shown tab lands on the left. The menu placement is contributed
+ * declaratively 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,61 @@ 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,
+ * whichever side a tab currently lives on. Hiding detaches the widget
+ * (`widget.parent = null`) while keeping the instance for a later
+ * re-add; the preference persists in this plugin's settings. Which side
+ * a hidden tab came from is only tracked in-memory, so after a reload a
+ * re-shown tab lands on the left. The menu placement is contributed
+ * declaratively 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;
+        // Side each hidden widget was removed from, so re-showing restores it
+        // there.
+        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 +102,28 @@ 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.
+                // Not seen yet (extension disabled or not added) — nothing to do.
+                return;
+            }
+            const area = locate(target.id);
+            if (!area && widget.parent !== null) {
+                // Attached outside the sidebars — leave it alone.
                 return;
             }
-            const present = findInSidebar(target.id) !== null;
             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 +136,27 @@ 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 registry (or the write failed): apply in-memory
+                    // for the current session only.
                     apply(target);
                     commands.notifyCommandChanged(target.command);
                 }
@@ -140,11 +177,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/terminals/index.d.ts

@@ -17,9 +17,11 @@ import { IAgentTerminals } from './tokens';
  *
  * Clicking a row activates the existing tab if one is open, or reopens
  * the session in a fresh terminal widget (`terminal:open`). The inline
- * `×` button shuts the session down on the server. The header carries a
- * `+` button and a stop button (the latter shuts every session down at
- * once, after a confirmation).
+ * `×` button shuts the session down on the server. The Terminals
+ * section's title toolbar carries a `+` button and a stop button (the
+ * latter shuts every session down at once, after a confirmation).
+ *
+ * The list is one movable section, and other panels' sections can move in.
  *
  * The `+` button drops down a menu — built from the launcher's shared
  * `IAgentRegistry` — listing each available agent (Claude, Codex, …)