xtralab 0.10.0 → 0.11.1

package/lib/omnibox/widget.js

@@ -0,0 +1,161 @@
+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.
+ */
+function renderHighlight(text, indices) {
+    if (indices.length === 0) {
+        return text;
+    }
+    const matched = new Set(indices);
+    const nodes = [];
+    let i = 0;
+    while (i < text.length) {
+        const isMatch = matched.has(i);
+        let j = i;
+        while (j < text.length && matched.has(j) === isMatch) {
+            j++;
+        }
+        const chunk = text.slice(i, j);
+        nodes.push(isMatch ? (React.createElement("span", { className: "jp-xtralab-Omnibox-match", key: i }, chunk)) : (React.createElement(React.Fragment, { key: i }, chunk)));
+        i = j;
+    }
+    return nodes;
+}
+function renderIcon(icon) {
+    return icon ? (React.createElement(icon.react, { tag: "span", className: "jp-xtralab-Omnibox-itemIcon" })) : (React.createElement("span", { className: "jp-xtralab-Omnibox-itemIcon" }));
+}
+function OmniboxComponent(props) {
+    const { commands, docRegistry, agents, placeholder, initialQuery, trans, onClose } = props;
+    const [query, setQuery] = React.useState(initialQuery);
+    const [files, setFiles] = React.useState([]);
+    const [active, setActive] = React.useState(0);
+    const inputRef = React.useRef(null);
+    const listRef = React.useRef(null);
+    React.useEffect(() => {
+        var _a;
+        (_a = inputRef.current) === null || _a === void 0 ? void 0 : _a.focus();
+    }, []);
+    React.useEffect(() => {
+        let cancelled = false;
+        void loadWorkspaceFiles().then(loaded => {
+            if (!cancelled) {
+                setFiles(loaded);
+            }
+        });
+        return () => {
+            cancelled = true;
+        };
+    }, []);
+    const sections = React.useMemo(() => computeSections({ query, commands, docRegistry, agents, files, trans }), [query, commands, docRegistry, agents, files, trans]);
+    const flat = React.useMemo(() => [...sections.commands, ...sections.files, ...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.
+        window.setTimeout(onClose, 0);
+    }, [onClose]);
+    const run = React.useCallback((item) => {
+        window.setTimeout(() => {
+            onClose();
+            item.execute();
+        }, 0);
+    }, [onClose]);
+    const onKeyDown = (event) => {
+        switch (event.key) {
+            case 'ArrowDown':
+                event.preventDefault();
+                event.stopPropagation();
+                setActive(current => Math.min(current + 1, flat.length - 1));
+                break;
+            case 'ArrowUp':
+                event.preventDefault();
+                event.stopPropagation();
+                setActive(current => Math.max(current - 1, 0));
+                break;
+            case 'Enter': {
+                event.preventDefault();
+                event.stopPropagation();
+                const item = flat[active];
+                if (item) {
+                    run(item);
+                }
+                break;
+            }
+            case 'Escape':
+                event.preventDefault();
+                event.stopPropagation();
+                dismiss();
+                break;
+            default:
+                break;
+        }
+    };
+    const renderSection = (title, items, startIndex) => {
+        if (items.length === 0) {
+            return null;
+        }
+        return (React.createElement("div", { className: "jp-xtralab-Omnibox-section", role: "group", "aria-label": title, key: title },
+            React.createElement("div", { className: "jp-xtralab-Omnibox-sectionHeader", "aria-hidden": "true" }, title),
+            items.map((item, offset) => {
+                const index = startIndex + offset;
+                const isActive = index === active;
+                return (React.createElement("div", { key: item.key, id: optionId(index), role: "option", "aria-selected": isActive, className: 'jp-xtralab-Omnibox-item' + (isActive ? ' jp-mod-active' : ''), onMouseEnter: () => setActive(index), onClick: () => run(item) },
+                    renderIcon(item.icon),
+                    React.createElement("span", { className: "jp-xtralab-Omnibox-itemLabel" }, renderHighlight(item.label, item.matchIndices)),
+                    item.caption ? (React.createElement("span", { className: "jp-xtralab-Omnibox-itemCaption" }, item.caption)) : null));
+            })));
+    };
+    const filesStart = sections.commands.length;
+    const agentsStart = filesStart + sections.files.length;
+    return (React.createElement("div", { className: "jp-xtralab-Omnibox-overlay", onMouseDown: event => {
+            if (event.target === event.currentTarget) {
+                dismiss();
+            }
+        } },
+        React.createElement("div", { className: "jp-xtralab-Omnibox-panel", role: "dialog", "aria-modal": "true", "aria-label": placeholder, onMouseDown: event => event.stopPropagation() },
+            React.createElement("input", { ref: inputRef, className: "jp-xtralab-Omnibox-input", type: "text", spellCheck: false, placeholder: placeholder, "aria-label": placeholder, role: "combobox", "aria-autocomplete": "list", "aria-expanded": hasResults, "aria-controls": LIST_ID, "aria-activedescendant": hasResults ? optionId(active) : undefined, value: query, onChange: event => setQuery(event.target.value), onKeyDown: onKeyDown }),
+            React.createElement("div", { className: "jp-xtralab-Omnibox-results", id: LIST_ID, role: hasResults ? 'listbox' : undefined, ref: listRef }, hasResults ? (React.createElement(React.Fragment, null,
+                renderSection(trans.__('Commands'), sections.commands, 0),
+                renderSection(trans.__('Files'), sections.files, filesStart),
+                renderSection(trans.__('Ask an agent'), sections.agents, agentsStart))) : (React.createElement("div", { className: "jp-xtralab-Omnibox-empty" }, query.trim()
+                ? trans.__('No matches.')
+                : 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).
+ */
+export class OmniboxWidget extends ReactWidget {
+    constructor(options) {
+        super();
+        this._options = options;
+        this.id = 'xtralab-omnibox';
+        this.addClass('jp-xtralab-Omnibox');
+        this.addClass('jp-ThemedContainer');
+    }
+    render() {
+        return React.createElement(OmniboxComponent, { ...this._options });
+    }
+}

package/lib/searchReplace/index.d.ts

@@ -0,0 +1,25 @@
+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.
+ */
+declare const plugin: JupyterFrontEndPlugin<void>;
+export default plugin;

package/lib/searchReplace/index.js

@@ -0,0 +1,68 @@
+import { ILabShell } from '@jupyterlab/application';
+import { ICommandPalette } from '@jupyterlab/apputils';
+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.
+ */
+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.
+ */
+const plugin = {
+    id: PLUGIN_ID,
+    description: 'Activate the Search and Replace panel with Accel+Shift+F (Cmd/Ctrl+Shift+F).',
+    autoStart: true,
+    requires: [ILabShell],
+    optional: [ICommandPalette, ITranslator],
+    activate: (app, labShell, palette, translator) => {
+        const trans = (translator !== null && translator !== void 0 ? translator : nullTranslator).load('jupyterlab');
+        const { commands } = app;
+        commands.addCommand(COMMAND_ID, {
+            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
+                // `jupyterlab-search-replace` is unavailable.
+                labShell.activateById(SEARCH_REPLACE_WIDGET_ID);
+            }
+        });
+        commands.addKeyBinding({
+            command: COMMAND_ID,
+            keys: ['Accel Shift F'],
+            selector: 'body'
+        });
+        if (palette) {
+            palette.addItem({
+                command: COMMAND_ID,
+                category: trans.__('File Operations')
+            });
+        }
+    }
+};
+export default plugin;

package/lib/showOutput/index.d.ts

@@ -0,0 +1,17 @@
+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.
+ */
+declare const plugin: JupyterFrontEndPlugin<void>;
+export default plugin;

package/lib/showOutput/index.js

@@ -0,0 +1,154 @@
+import { ILabShell } from '@jupyterlab/application';
+import { ICommandPalette } from '@jupyterlab/apputils';
+import { IRenderMimeRegistry } from '@jupyterlab/rendermime';
+import { ITranslator, nullTranslator } from '@jupyterlab/translation';
+import { Panel } from '@lumino/widgets';
+const PLUGIN_ID = 'xtralab:show-output';
+/** Render arbitrary rich content into a panel, with no notebook and no kernel. */
+const SHOW_COMMAND = 'xtralab:show';
+/**
+ * Parse a JSON-typed value that may have arrived as a string. Agents and the
+ * MCP bridge sometimes serialize a spec (e.g. a Vega-Lite object) to a string;
+ * for `application/...json` MIME types we accept either and parse the string.
+ */
+function coerceData(mimeType, data) {
+    if (typeof data === 'string' && /\+?json$/.test(mimeType)) {
+        try {
+            return JSON.parse(data);
+        }
+        catch (_a) {
+            return data;
+        }
+    }
+    return data;
+}
+/**
+ * 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.
+ */
+const plugin = {
+    id: PLUGIN_ID,
+    description: 'Render rich content (Markdown, Vega-Lite, HTML, images) into a panel.',
+    autoStart: true,
+    requires: [IRenderMimeRegistry, ILabShell],
+    optional: [ICommandPalette, ITranslator],
+    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'),
+            caption: trans.__('Render Markdown, a Vega-Lite chart, HTML, or an image in a panel'),
+            describedBy: {
+                args: {
+                    type: 'object',
+                    required: ['mimeType', 'data'],
+                    properties: {
+                        mimeType: {
+                            type: 'string',
+                            description: 'MIME type to render, e.g. "text/markdown", "application/vnd.vegalite.v5+json", "text/html", "image/svg+xml", "image/png".'
+                        },
+                        data: {
+                            description: 'The content. A string for text/image types (base64 for "image/png"); an object for JSON types such as a Vega-Lite spec.'
+                        },
+                        label: {
+                            type: 'string',
+                            description: 'Title for the panel tab. Defaults to "Output".'
+                        },
+                        id: {
+                            type: 'string',
+                            description: 'Panel identifier. Calls sharing an `id` reuse one panel; defaults to "default".'
+                        },
+                        area: {
+                            type: 'string',
+                            description: 'Where the panel docks: "right" (default) puts it in the side area so the editor stays full width; "main" puts it in the document area (split with `mode`).'
+                        },
+                        mode: {
+                            type: 'string',
+                            description: 'Only when `area` is "main": placement relative to the active tab, e.g. "split-right" (default), "split-bottom", "tab-after".'
+                        }
+                    }
+                }
+            },
+            execute: async (args) => {
+                const mimeType = typeof args['mimeType'] === 'string' ? args['mimeType'] : undefined;
+                if (!mimeType || args['data'] === undefined) {
+                    throw new Error('xtralab:show requires "mimeType" and "data"');
+                }
+                const data = coerceData(mimeType, args['data']);
+                const label = typeof args['label'] === 'string'
+                    ? args['label']
+                    : trans.__('Output');
+                const id = typeof args['id'] === 'string' ? args['id'] : 'default';
+                const area = args['area'] === 'main' ? 'main' : 'right';
+                const mode = typeof args['mode'] === 'string' ? args['mode'] : 'split-right';
+                const bundle = { [mimeType]: data };
+                const chosen = rendermime.preferredMimeType(bundle, 'any');
+                if (!chosen) {
+                    throw new Error(`xtralab:show: no renderer for MIME type "${mimeType}"`);
+                }
+                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).
+                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();
+                }
+                panels.set(id, widget);
+                widget.disposed.connect(() => {
+                    if (panels.get(id) === widget) {
+                        panels.delete(id);
+                    }
+                });
+                // 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".
+                if (area === 'main') {
+                    labShell.add(widget, 'main', {
+                        mode: mode,
+                        activate: true
+                    });
+                }
+                else {
+                    labShell.add(widget, 'right', { rank: 900 });
+                }
+                // Reveal the panel (the side area does not open from `add` alone).
+                labShell.activateById(widget.id);
+                try {
+                    await renderer.renderModel(model);
+                }
+                catch (error) {
+                    widget.dispose();
+                    throw error instanceof Error
+                        ? error
+                        : new Error(`xtralab:show: failed to render "${mimeType}"`);
+                }
+                return trans.__('Rendered %1 in "%2"', mimeType, label);
+            }
+        });
+        if (palette) {
+            palette.addItem({ command: SHOW_COMMAND, category: trans.__('Other') });
+        }
+    }
+};
+export default plugin;

package/lib/terminals/index.d.ts

@@ -9,6 +9,10 @@ import { JupyterFrontEndPlugin } from '@jupyterlab/application';
  * 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

package/lib/terminals/index.js

@@ -1,5 +1,6 @@
 import { ILayoutRestorer } from '@jupyterlab/application';
 import { Dialog, showDialog } from '@jupyterlab/apputils';
+import { ISettingRegistry } from '@jupyterlab/settingregistry';
 import { ITerminalTracker } from '@jupyterlab/terminal';
 import { ITranslator, nullTranslator } from '@jupyterlab/translation';
 import { MenuSvg, terminalIcon } from '@jupyterlab/ui-components';
@@ -19,6 +20,10 @@ const PLUGIN_ID = 'xtralab:terminals';
  * 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
@@ -43,26 +48,30 @@ const plugin = {
         ITranslator,
         IAgentRegistry,
         IEditorRegistry,
-        IAgentSessions
+        IAgentSessions,
+        ISettingRegistry
     ],
-    activate: (app, tracker, restorer, translator, agentRegistry, editorRegistry, agentSessions) => {
+    activate: (app, tracker, restorer, translator, agentRegistry, editorRegistry, agentSessions, settingRegistry) => {
         const trans = (translator !== null && translator !== void 0 ? translator : nullTranslator).load('jupyterlab');
-        // Resolve a session's running command 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. Reads `agentRegistry.agents`
-        // live so it tracks settings changes. Used by the panel to badge each row.
+        // 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.
         const iconForCommand = (command) => {
             var _a;
             if (!command) {
                 return terminalIcon;
             }
-            const agent = agentRegistry === null || agentRegistry === void 0 ? void 0 : agentRegistry.agents.find(a => a.command === command);
+            const agent = agentRegistry === null || agentRegistry === void 0 ? void 0 : agentRegistry.agents.find(a => a.command === command || a.id === command);
             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);
+            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;
         };
         const registry = new SessionRegistry({
@@ -73,16 +82,32 @@ const plugin = {
             // nothing while a notebook or other widget is current instead).
             shell: app.shell,
             agentSessions,
-            // The commands the server should look for: the current agent and editor
-            // lists, each read live from its registry so they track settings changes
-            // — a terminal running an agent or an editor (Neovim/Vim, or a configured
-            // one) is badged.
+            // 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.
             detectCommands: () => {
                 var _a, _b;
-                return [
-                    ...((_a = agentRegistry === null || agentRegistry === void 0 ? void 0 : agentRegistry.agents.map(a => a.command)) !== null && _a !== void 0 ? _a : []),
-                    ...((_b = editorRegistry === null || editorRegistry === void 0 ? void 0 : editorRegistry.editors.map(e => e.command)) !== null && _b !== void 0 ? _b : [])
-                ];
+                const names = new Set();
+                for (const agent of (_a = agentRegistry === null || agentRegistry === void 0 ? void 0 : agentRegistry.agents) !== null && _a !== void 0 ? _a : []) {
+                    names.add(agent.command);
+                    names.add(agent.id);
+                }
+                for (const editor of (_b = editorRegistry === null || editorRegistry === void 0 ? void 0 : editorRegistry.editors) !== null && _b !== void 0 ? _b : []) {
+                    names.add(editor.command);
+                    names.add(editor.id);
+                }
+                return Array.from(names);
+            },
+            // Only coding agents (not editors) get a latest-activity line, so the
+            // registry asks this whether a detected command/id is an agent before
+            // reading its output buffer — editor terminals stay badge-only.
+            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;
             }
         });
         // Mirror the agent/editor detected in each open terminal onto its main-area
@@ -189,6 +214,30 @@ const plugin = {
         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.
+        if (settingRegistry) {
+            settingRegistry
+                .load(PLUGIN_ID)
+                .then(settings => {
+                const applyActivitySetting = () => {
+                    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.
+                settings.changed.connect(applyActivitySetting, panel);
+            })
+                .catch(reason => {
+                console.error(`xtralab: failed to load ${PLUGIN_ID} settings`, reason);
+            });
+        }
     }
 };
+/** Read a boolean setting value, falling back when it is missing or invalid. */
+function boolOption(value, fallback) {
+    return typeof value === 'boolean' ? value : fallback;
+}
 export default plugin;