xtralab 0.14.1 → 0.15.1

package/lib/terminalNotifications/index.js

@@ -12,16 +12,10 @@ const OSC_ITERM2_GROWL = 9;
 const OSC_RXVT_NOTIFY = 777;
 const MAX_TEXT_LENGTH = 256;
 /**
- * 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.
  */
 const plugin = {
     id: PLUGIN_ID,
@@ -34,12 +28,8 @@ const plugin = {
         const trans = (translator !== null && translator !== void 0 ? translator : nullTranslator).load('jupyterlab');
         let enabled = true;
         let notifyOnBell = true;
-        // Per-widget throttle timestamps and xterm hooks. WeakMaps let disposed
-        // widgets be collected; hooks are torn down when a tab closes.
         const lastNotified = new WeakMap();
         const hooks = new WeakMap();
-        // True when the user is already looking at this terminal, so a banner would
-        // just be noise.
         const isActivelyViewing = (widget) => document.hasFocus() && app.shell.currentWidget === widget;
         const deliver = (title, body, session) => {
             const bridge = window.xtralab;
@@ -49,7 +39,6 @@ const plugin = {
                 });
                 return;
             }
-            // Plain-browser fallback (pip install): the Web Notifications API.
             if (typeof Notification === 'undefined') {
                 return;
             }
@@ -82,9 +71,8 @@ const plugin = {
         // it, so it reads well as the title for body-only sequences (OSC 9, bell).
         const labelOf = (widget) => widget.title.label || trans.__('Terminal');
         const onOsc9 = (widget, data) => {
-            // OSC 9 is overloaded: ConEmu/Windows Terminal use `9 ; <n> ; …`
-            // subcommands (e.g. `9 ; 4` progress), so skip a numeric-subcommand
-            // payload and leave it unconsumed rather than treat it as a notification.
+            // OSC 9 is overloaded: ConEmu/Windows Terminal use numeric subcommands
+            // (e.g. `9 ; 4` progress); leave those unconsumed.
             if (/^\d+(;|$)/.test(data)) {
                 return false;
             }
@@ -129,8 +117,6 @@ const plugin = {
                     console.warn('xtralab: xterm internals not found; terminal notifications are disabled for this terminal');
                     return;
                 }
-                // Handlers are wrapped so a parse slip cannot break xterm's parser; an
-                // OSC handler returns whether it consumed the sequence.
                 const disposables = [
                     term.onBell(() => guard(() => onBell(widget))),
                     term.parser.registerOscHandler(OSC_ITERM2_GROWL, data => guardOsc(() => onOsc9(widget, data))),

package/lib/terminals/agentTerminals.d.ts

@@ -6,16 +6,23 @@ import type { SessionRegistry } from './model';
 import type { IAgentTerminalSession, IAgentTerminals } from './tokens';
 /**
  * The {@link IAgentTerminals} implementation: a read-only view over the
- * terminals panel's {@link SessionRegistry} narrowed to sessions with a
- * detection-confirmed coding agent, plus the "send a prompt into one"
- * action. Lives in the `xtralab:terminals` plugin so the ask-agent popup
- * (and any future caller) can target running agents without duplicating the
- * detection plumbing.
+ * panel's {@link SessionRegistry} narrowed to sessions with a
+ * detection-confirmed coding agent, plus the "send a prompt into one" action.
  */
 export declare class AgentTerminals implements IAgentTerminals {
     constructor(options: AgentTerminals.IOptions);
+    /**
+     * Snapshot of the sessions with a detection-confirmed running agent.
+     */
     sessions(): IAgentTerminalSession[];
+    /**
+     * A signal emitted whenever the {@link sessions} snapshot may have changed.
+     */
     get changed(): ISignal<IAgentTerminals, void>;
+    /**
+     * Paste the prompt into the named session and press Enter, re-validating
+     * with the server first that an agent still runs there.
+     */
     sendPrompt(name: string, prompt: string): Promise<void>;
     private _findWidget;
     private _onRegistryStateChanged;

package/lib/terminals/agentTerminals.js

@@ -1,32 +1,20 @@
 import { Signal } from '@lumino/signaling';
 import { fetchRunningAgents } from './detection';
 /**
- * Pause between pasting the prompt and pressing Enter, so the two reach the
- * agent as separate PTY reads — the same shape as a human pasting and then
- * submitting. Sent back to back, the server can coalesce both websocket
- * messages into one read and the TUI would have to split the paste from the
- * trailing Enter inside a single chunk.
+ * Pause between pasting the prompt and pressing Enter so the server cannot
+ * coalesce both websocket messages into one PTY read.
  */
 const PASTE_SUBMIT_DELAY_MS = 150;
 /**
- * Bracketed-paste markers (`CSI 200~` / `CSI 201~`). The prompt is wrapped
- * in these so the agent's TUI treats it as one pasted block — newlines
- * insert into its input box instead of submitting the message at each line
- * break. Every send target is a terminal where detection just confirmed a
- * running coding agent, and the agent TUIs keep bracketed-paste mode on.
+ * Bracketed-paste markers (`CSI 200~` / `CSI 201~`): a wrapped prompt arrives
+ * as one pasted block, so newlines insert instead of submitting at each break.
  */
 const PASTE_OPEN = '\x1b[200~';
 const PASTE_CLOSE = '\x1b[201~';
-/**
- * How long to wait for the session's websocket to reach `connected` before
- * failing the send, so a server hiccup surfaces as an error notification
- * rather than a silent hang.
- */
 const CONNECT_TIMEOUT_MS = 10000;
 /**
  * Resolve once `session` reports `connected`; reject with `timeoutMessage`
- * after {@link CONNECT_TIMEOUT_MS}. Matches how the launcher waits before
- * typing into a fresh terminal — writes sent while the websocket is still
+ * after {@link CONNECT_TIMEOUT_MS} — writes sent while the websocket is still
  * connecting disappear silently.
  */
 function waitUntilConnected(session, timeoutMessage) {
@@ -53,11 +41,8 @@ function waitUntilConnected(session, timeoutMessage) {
 }
 /**
  * The {@link IAgentTerminals} implementation: a read-only view over the
- * terminals panel's {@link SessionRegistry} narrowed to sessions with a
- * detection-confirmed coding agent, plus the "send a prompt into one"
- * action. Lives in the `xtralab:terminals` plugin so the ask-agent popup
- * (and any future caller) can target running agents without duplicating the
- * detection plumbing.
+ * panel's {@link SessionRegistry} narrowed to sessions with a
+ * detection-confirmed coding agent, plus the "send a prompt into one" action.
  */
 export class AgentTerminals {
     constructor(options) {
@@ -70,6 +55,9 @@ export class AgentTerminals {
         this._trans = options.trans;
         this._registry.stateChanged.connect(this._onRegistryStateChanged, this);
     }
+    /**
+     * Snapshot of the sessions with a detection-confirmed running agent.
+     */
     sessions() {
         const result = [];
         for (const name of this._registry.sessionNames()) {
@@ -86,14 +74,19 @@ export class AgentTerminals {
         }
         return result;
     }
+    /**
+     * A signal emitted whenever the {@link sessions} snapshot may have changed.
+     */
     get changed() {
         return this._changed;
     }
+    /**
+     * Paste the prompt into the named session and press Enter, re-validating
+     * with the server first that an agent still runs there.
+     */
     async sendPrompt(name, prompt) {
-        // Re-validate against the server rather than trusting the caller's
-        // (possibly seconds-old) snapshot: the prompt is prose, and prose pasted
-        // into the shell prompt left behind by an exited agent would be
-        // *executed* on the Enter below.
+        // Re-validate against the server: prose pasted into the shell prompt an
+        // exited agent left behind would be *executed* on the Enter below.
         await this._terminals.refreshRunning();
         const alive = Array.from(this._terminals.running()).some(model => model.name === name);
         if (!alive) {
@@ -101,47 +94,35 @@ export class AgentTerminals {
         }
         const detected = await fetchRunningAgents(this._detectCommands());
         if (detected === null) {
-            // Detection being unavailable (older server, transient failure) is
-            // not proof the agent is gone; refuse the write with a message that
-            // invites the retry that would succeed.
+            // Detection unavailable (older server, transient failure) is not proof
+            // the agent is gone; refuse the write and invite a retry.
             throw new Error(this._trans.__('Could not verify the terminal — try sending again.'));
         }
         const command = detected[name];
         if (typeof command !== 'string' || !this._isAgentCommand(command)) {
             throw new Error(this._trans.__('No agent is running in that terminal anymore.'));
         }
-        // Deliver in the background: write straight to the session over its
-        // websocket instead of revealing its tab, so focus stays wherever the
-        // user is asking from. An open tab's live connection is reused; a
-        // closed tab gets a short-lived client connection to the running server
-        // session, without creating any widget.
         const widget = this._findWidget(name);
         const session = widget !== null
             ? widget.content.session
             : this._terminals.connectTo({ model: { name } });
         try {
             await waitUntilConnected(session, this._trans.__('Timed out connecting to the terminal.'));
-            // Wrapped and newline-normalised exactly like xterm's own paste
-            // handling. Writing the markers directly (rather than through an open
-            // tab's `Terminal.paste`) also sidesteps the one case paste() gets
-            // wrong: a freshly reconnected xterm whose replayed scrollback no
-            // longer holds the agent's original mode-setting escape, which makes
-            // paste() skip the wrapping the application still expects.
+            // Writing the markers directly (not `Terminal.paste`) sidesteps paste()
+            // skipping them on a reconnected xterm that lost the mode-setting escape.
             session.send({
                 type: 'stdin',
                 content: [PASTE_OPEN + prompt.replace(/\r?\n/g, '\r') + PASTE_CLOSE]
             });
             await new Promise(resolve => window.setTimeout(resolve, PASTE_SUBMIT_DELAY_MS));
             if (session.isDisposed) {
-                // The tab closed during the pause; the pasted text already reached
-                // the agent's input box but Enter can no longer be delivered here.
                 throw new Error(this._trans.__('The terminal closed before the prompt was submitted.'));
             }
             session.send({ type: 'stdin', content: ['\r'] });
         }
         finally {
-            // Close a connection we opened just for this send. Disposing the
-            // client connection leaves the server session (and its agent) running.
+            // Disposing an ad-hoc client connection leaves the server session
+            // (and its agent) running.
             if (widget === null && !session.isDisposed) {
                 session.dispose();
             }

package/lib/terminals/detection.d.ts

@@ -1,11 +1,7 @@
 /**
- * Ask the xtralab server which of `commands` is currently running inside each
- * open terminal session. Resolves to a map from session name to the matched
- * agent command, or `null` for a session sitting at its prompt.
- *
- * On any failure (endpoint missing on an older server, network error,
- * malformed response) the whole result is `null` — callers should treat that
- * as "detection unavailable" and fall back to the optimistic launch tags
- * rather than clearing any badges.
+ * Ask the xtralab server which of `commands` runs in each open terminal
+ * session: a map from session name to matched command (`null` = idle). Any
+ * failure resolves the whole result to `null` — "detection unavailable",
+ * not "no agents"; callers must not clear badges on it.
  */
 export declare function fetchRunningAgents(commands: string[]): Promise<Record<string, string | null> | null>;

package/lib/terminals/detection.js

@@ -1,14 +1,10 @@
 import { URLExt } from '@jupyterlab/coreutils';
 import { ServerConnection } from '@jupyterlab/services';
 /**
- * Ask the xtralab server which of `commands` is currently running inside each
- * open terminal session. Resolves to a map from session name to the matched
- * agent command, or `null` for a session sitting at its prompt.
- *
- * On any failure (endpoint missing on an older server, network error,
- * malformed response) the whole result is `null` — callers should treat that
- * as "detection unavailable" and fall back to the optimistic launch tags
- * rather than clearing any badges.
+ * Ask the xtralab server which of `commands` runs in each open terminal
+ * session: a map from session name to matched command (`null` = idle). Any
+ * failure resolves the whole result to `null` — "detection unavailable",
+ * not "no agents"; callers must not clear badges on it.
  */
 export async function fetchRunningAgents(commands) {
     if (commands.length === 0) {

package/lib/terminals/index.d.ts

@@ -1,37 +1,4 @@
 import { JupyterFrontEndPlugin } from '@jupyterlab/application';
 import { IAgentTerminals } from './tokens';
-/**
- * Adds a left-sidebar panel that lists every running terminal session.
- *
- * Each row is labelled with the *real* title the running program
- * published — the launcher's agent name, or whatever title an xterm
- * escape sequence set — which the registry caches so it survives the
- * user closing the tab while the session keeps running on the server.
- * JupyterLab's built-in "Running Terminals and Kernels" panel lists the
- * same sessions but only by their `terminals/<n>` name, so this panel
- * resolves and caches the published title to show something meaningful.
- * Rows running a coding agent carry a smaller second line below the
- * title with the agent's latest line of output, so the panel shows what
- * each agent is doing at a glance — on by default, and switchable off
- * through the `showAgentActivity` setting.
- *
- * 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).
- *
- * The `+` button drops down a menu — built from the launcher's shared
- * `IAgentRegistry` — listing each available agent (Claude, Codex, …)
- * followed by a plain terminal, so starting an agent session is as
- * consistent here as in the launcher and reuses the very same registered
- * commands and icons. When the launcher is disabled or no agents are
- * installed, the button falls back to opening a plain terminal directly.
- *
- * The plugin also provides {@link IAgentTerminals} — the sessions with a
- * detection-confirmed running agent, plus a "paste a prompt into one"
- * action — which the ask-agent popup uses to offer running agents as
- * targets next to "new terminal".
- */
 declare const plugin: JupyterFrontEndPlugin<IAgentTerminals>;
 export default plugin;

package/lib/terminals/index.js

@@ -1,5 +1,5 @@
 import { ILayoutRestorer } from '@jupyterlab/application';
-import { Dialog, showDialog } from '@jupyterlab/apputils';
+import { Dialog, IMovableSectionRegistry, showDialog } from '@jupyterlab/apputils';
 import { ISettingRegistry } from '@jupyterlab/settingregistry';
 import { ITerminalTracker } from '@jupyterlab/terminal';
 import { ITranslator, nullTranslator } from '@jupyterlab/translation';
@@ -12,39 +12,6 @@ import { SessionRegistry } from './model';
 import { IAgentTerminals } from './tokens';
 import { RunningTerminals } from './widget';
 const PLUGIN_ID = 'xtralab:terminals';
-/**
- * Adds a left-sidebar panel that lists every running terminal session.
- *
- * Each row is labelled with the *real* title the running program
- * published — the launcher's agent name, or whatever title an xterm
- * escape sequence set — which the registry caches so it survives the
- * user closing the tab while the session keeps running on the server.
- * JupyterLab's built-in "Running Terminals and Kernels" panel lists the
- * same sessions but only by their `terminals/<n>` name, so this panel
- * resolves and caches the published title to show something meaningful.
- * Rows running a coding agent carry a smaller second line below the
- * title with the agent's latest line of output, so the panel shows what
- * each agent is doing at a glance — on by default, and switchable off
- * through the `showAgentActivity` setting.
- *
- * 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).
- *
- * The `+` button drops down a menu — built from the launcher's shared
- * `IAgentRegistry` — listing each available agent (Claude, Codex, …)
- * followed by a plain terminal, so starting an agent session is as
- * consistent here as in the launcher and reuses the very same registered
- * commands and icons. When the launcher is disabled or no agents are
- * installed, the button falls back to opening a plain terminal directly.
- *
- * The plugin also provides {@link IAgentTerminals} — the sessions with a
- * detection-confirmed running agent, plus a "paste a prompt into one"
- * action — which the ask-agent popup uses to offer running agents as
- * targets next to "new terminal".
- */
 const plugin = {
     id: PLUGIN_ID,
     description: 'A left-sidebar panel listing every running terminal session by its real (program-published) title, with activate/reopen, shutdown and new-terminal actions.',
@@ -57,17 +24,13 @@ const plugin = {
         IAgentRegistry,
         IEditorRegistry,
         IAgentSessions,
-        ISettingRegistry
+        ISettingRegistry,
+        IMovableSectionRegistry
     ],
-    activate: (app, tracker, restorer, translator, agentRegistry, editorRegistry, agentSessions, settingRegistry) => {
+    activate: (app, tracker, restorer, translator, agentRegistry, editorRegistry, agentSessions, settingRegistry, movableSections) => {
         const trans = (translator !== null && translator !== void 0 ? translator : nullTranslator).load('jupyterlab');
-        // Resolve a running agent/editor identifier to an icon: the matching
-        // agent's logo, the matching editor's logo (Neovim/Vim), or the plain
-        // terminal icon when nothing recognised is running. Detection reports
-        // either the configured `command` or the canonical `id` (see
-        // `detectCommands`), so a row whose command is an alias — e.g. `ccm` for
-        // `claude` — still resolves to the right logo via its id. Reads the
-        // registries live so it tracks settings changes. Used to badge each row.
+        // Detection reports either the configured `command` or the canonical `id`,
+        // so an aliased command (e.g. `ccm` for `claude`) still maps to its logo.
         const iconForCommand = (command) => {
             var _a;
             if (!command) {
@@ -77,18 +40,9 @@ const plugin = {
             if (agent) {
                 return agent.icon;
             }
-            // A terminal running an editor (Neovim/Vim, or a user-configured one) is
-            // badged with its logo, the same as an agent.
             const editor = editorRegistry === null || editorRegistry === void 0 ? void 0 : editorRegistry.editors.find(e => e.command === command || e.id === command);
             return (_a = editor === null || editor === void 0 ? void 0 : editor.icon) !== null && _a !== void 0 ? _a : terminalIcon;
         };
-        // The names the server should look for in each terminal's process tree:
-        // for every agent and editor, its configured `command` plus its canonical
-        // `id`. The id is the real CLI name (e.g. `claude`, `nvim`), so an agent
-        // whose command points at an alias — e.g. `ccm` running `claude` — is
-        // still recognised by the process it actually spawns. Read live so the
-        // list tracks settings changes; deduplicated since command and id usually
-        // coincide.
         const detectCommands = () => {
             var _a, _b;
             const names = new Set();
@@ -102,10 +56,6 @@ const plugin = {
             }
             return Array.from(names);
         };
-        // Whether a detected command/id belongs to a coding agent rather than an
-        // editor. Only agent sessions get a latest-activity line (editor
-        // terminals stay badge-only), and only they are offered as prompt
-        // targets through `IAgentTerminals`.
         const isAgentCommand = (command) => {
             var _a;
             return (_a = agentRegistry === null || agentRegistry === void 0 ? void 0 : agentRegistry.agents.some(a => a.command === command || a.id === command)) !== null && _a !== void 0 ? _a : false;
@@ -113,18 +63,13 @@ const plugin = {
         const registry = new SessionRegistry({
             serviceManager: app.serviceManager,
             tracker,
-            // The shell tells the registry which widget is current, so the panel can
-            // highlight the terminal that is the current main-area widget (and
-            // nothing while a notebook or other widget is current instead).
             shell: app.shell,
             agentSessions,
             detectCommands,
             isAgentCommand
         });
-        // Mirror the agent/editor detected in each open terminal onto its main-area
-        // tab icon, so the tab matches its sidebar row. Re-running on every
-        // `stateChanged` is safe: `Title.icon` ignores an unchanged assignment, so
-        // the writes neither loop nor churn.
+        // `Title.icon` ignores an unchanged assignment, so re-running per
+        // stateChanged is cheap.
         const syncTabIcons = () => {
             tracker.forEach(widget => {
                 const session = widget.content.session;
@@ -137,10 +82,8 @@ const plugin = {
         registry.stateChanged.connect(syncTabIcons);
         syncTabIcons();
         const onActivate = (name) => {
-            // `terminal:open` is the upstream entry point that handles both
-            // sides of this: if a widget is already attached to the named
-            // session it activates that tab, otherwise it spins up a fresh
-            // widget connected to the live session.
+            // `terminal:open` activates an attached tab or spins up a fresh widget
+            // connected to the live session.
             void app.commands.execute('terminal:open', { name });
         };
         const onShutdown = (name) => {
@@ -149,10 +92,6 @@ const plugin = {
             });
         };
         const onShutdownAll = () => {
-            // Tearing down every session at once is hard to undo (each may be a
-            // running agent), so confirm before calling the manager's bulk
-            // shutdown. `runningChanged` then clears the list and the panel
-            // re-renders empty.
             void showDialog({
                 title: trans.__('Shut Down All Terminals?'),
                 body: trans.__('Are you sure you want to permanently shut down all running terminals?'),
@@ -170,19 +109,8 @@ const plugin = {
                 console.error(`xtralab: failed to shut down all terminals: ${reason}`);
             });
         };
-        // The header "+" button. With the launcher's agent registry available
-        // it drops down a menu of the available agents (reusing their registered
-        // `xtralab:start-agent:<id>` commands, so the icons and labels match the
-        // launcher exactly) followed by a separator and a plain terminal. Built
-        // lazily and repopulated on each open so it always reflects the current,
-        // settings-driven agent list. Without the registry (launcher disabled)
-        // or with no agents installed, there is nothing to choose between, so
-        // the button opens a plain terminal directly in one click.
-        //
-        // `MenuSvg` (not the bare Lumino `Menu`) is what every JupyterLab menu
-        // uses: its renderer applies the `menuItem` LabIcon stylesheet, which
-        // sizes the agent icons to 16px and centers them vertically — the bare
-        // `Menu` renders the raw, oversized, misaligned SVGs.
+        // `MenuSvg`, not the bare Lumino `Menu`: its renderer applies the `menuItem`
+        // LabIcon stylesheet — the bare menu renders raw, oversized SVGs.
         let newMenu = null;
         const onCreate = (anchor) => {
             var _a;
@@ -211,22 +139,20 @@ const plugin = {
             onShutdownAll,
             onCreate
         });
-        // Added to the left sidebar. The shipped `layout` setting in
-        // jupyter-config/labconfig gives each sidebar widget a default rank —
-        // this Terminals panel ranks first, so running agents sit one click
-        // away at the top. That setting assigns rank only and pins no area, so
-        // the "Move Widget" context menu can relocate the panel and the layout
-        // restorer remembers where the user puts it. The `rank` here is the
-        // in-code fallback used when the setting is absent. Sessions restored
-        // from a previous lab run land via `runningChanged` once the terminal
-        // manager is ready, which the panel's `UseSignal` picks up.
+        // The shipped labconfig `layout` setting ranks this panel first (rank only,
+        // no area pin, so "Move Widget" works); this rank is the fallback.
         app.shell.add(panel, 'left', { rank: 1 });
         if (restorer) {
             restorer.add(panel, panel.id);
         }
-        // The latest-activity line under each agent row is on by default; honour
-        // the `showAgentActivity` setting so it can be turned off. Read on load and
-        // re-applied on every change.
+        void app.restored.then(() => {
+            panel.expandOwnSection();
+        });
+        if (movableSections) {
+            movableSections.registerSource(PLUGIN_ID, trans.__('Terminals'), panel);
+            movableSections.registerTarget(PLUGIN_ID, trans.__('Terminals'), panel);
+            panel.announceSections();
+        }
         if (settingRegistry) {
             settingRegistry
                 .load(PLUGIN_ID)
@@ -235,9 +161,8 @@ const plugin = {
                     registry.setActivityEnabled(boolOption(settings.composite.showAgentActivity, true));
                 };
                 applyActivitySetting();
-                // Bind the slot to the panel so disposing the panel (which clears
-                // its signal data) drops the connection — the disposed registry is
-                // then never reached on a later settings change.
+                // Bound to the panel so disposing it drops the connection — the
+                // disposed registry is never reached on a later settings change.
                 settings.changed.connect(applyActivitySetting, panel);
             })
                 .catch(reason => {
@@ -254,9 +179,6 @@ const plugin = {
         });
     }
 };
-/**
- * Read a boolean setting value, falling back when it is missing or invalid.
- */
 function boolOption(value, fallback) {
     return typeof value === 'boolean' ? value : fallback;
 }