xtralab 0.9.0 → 0.11.0

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/terminalNotifications/index.d.ts

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

package/lib/terminalNotifications/index.js

@@ -0,0 +1,213 @@
+import { ISettingRegistry } from '@jupyterlab/settingregistry';
+import { ITerminalTracker } from '@jupyterlab/terminal';
+import { ITranslator, nullTranslator } from '@jupyterlab/translation';
+const PLUGIN_ID = 'xtralab:terminal-notifications';
+// Per-terminal gap between notifications, so the OSC-9-plus-bell agents emit
+// together collapses into one and a chatty program cannot flood the OS.
+const NOTIFY_THROTTLE_MS = 3000;
+// iTerm2 growl notification: `ESC ] 9 ; <message> BEL`. What Claude Code and
+// most agents emit on their default `auto` setting once TERM_PROGRAM is set.
+const OSC_ITERM2_GROWL = 9;
+// rxvt/Ghostty notification: `ESC ] 777 ; notify ; <title> ; <body> BEL`.
+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.
+ */
+const plugin = {
+    id: PLUGIN_ID,
+    description: 'Forwards desktop notifications emitted by agents in xtralab terminals (OSC 9, OSC 777, bell) to the operating system.',
+    autoStart: true,
+    requires: [ITerminalTracker],
+    optional: [ISettingRegistry, ITranslator],
+    activate: async (app, tracker, settingRegistry, translator) => {
+        var _a;
+        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;
+            if (bridge && typeof bridge.notify === 'function') {
+                void Promise.resolve(bridge.notify(title, body, session)).catch(reason => {
+                    console.warn('xtralab: desktop notification failed', reason);
+                });
+                return;
+            }
+            // Plain-browser fallback (pip install): the Web Notifications API.
+            if (typeof Notification === 'undefined') {
+                return;
+            }
+            if (Notification.permission === 'granted') {
+                new Notification(title, { body });
+            }
+            else if (Notification.permission !== 'denied') {
+                void Notification.requestPermission().then(permission => {
+                    if (permission === 'granted') {
+                        new Notification(title, { body });
+                    }
+                });
+            }
+        };
+        const notify = (widget, title, body) => {
+            var _a;
+            if (!enabled || isActivelyViewing(widget)) {
+                return;
+            }
+            const now = Date.now();
+            const previous = lastNotified.get(widget);
+            if (previous !== undefined && now - previous < NOTIFY_THROTTLE_MS) {
+                return;
+            }
+            lastNotified.set(widget, now);
+            const session = (_a = widget.content.session) === null || _a === void 0 ? void 0 : _a.name;
+            deliver(sanitize(title) || 'xtralab', sanitize(body), session);
+        };
+        // The tab label is the agent's name once the launcher or an xterm title sets
+        // 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.
+            if (/^\d+(;|$)/.test(data)) {
+                return false;
+            }
+            const message = sanitize(data);
+            if (message) {
+                notify(widget, labelOf(widget), message);
+            }
+            return true;
+        };
+        const onOsc777 = (widget, data) => {
+            var _a;
+            // `notify ; <title> ; <body>`; a body may contain ';'. Other OSC 777
+            // subcommands are left unconsumed.
+            const parts = data.split(';');
+            if (parts.shift() !== 'notify') {
+                return false;
+            }
+            const title = sanitize((_a = parts.shift()) !== null && _a !== void 0 ? _a : '') || labelOf(widget);
+            const body = sanitize(parts.join(';'));
+            if (body || title) {
+                notify(widget, title, body);
+            }
+            return true;
+        };
+        const onBell = (widget) => {
+            if (notifyOnBell) {
+                notify(widget, labelOf(widget), trans.__('Activity in terminal'));
+            }
+        };
+        const hookWidget = (widget) => {
+            if (hooks.has(widget)) {
+                return;
+            }
+            const content = widget.content;
+            void content.ready
+                .then(() => {
+                const term = content._term;
+                if (widget.isDisposed) {
+                    return;
+                }
+                if (!term) {
+                    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))),
+                    term.parser.registerOscHandler(OSC_RXVT_NOTIFY, data => guardOsc(() => onOsc777(widget, data)))
+                ];
+                hooks.set(widget, disposables);
+                widget.disposed.connect(() => {
+                    for (const disposable of disposables) {
+                        disposable.dispose();
+                    }
+                    hooks.delete(widget);
+                });
+            })
+                .catch(reason => {
+                console.warn('xtralab: could not hook terminal notifications', reason);
+            });
+        };
+        tracker.forEach(hookWidget);
+        tracker.widgetAdded.connect((_, widget) => hookWidget(widget));
+        // Focus the terminal that fired a notification when the desktop shell
+        // reports a click. `terminal:open` activates its tab or reopens the session.
+        const desktopBridge = window
+            .xtralab;
+        (_a = desktopBridge === null || desktopBridge === void 0 ? void 0 : desktopBridge.onFocusTerminal) === null || _a === void 0 ? void 0 : _a.call(desktopBridge, session => {
+            if (session) {
+                void app.commands.execute('terminal:open', { name: session });
+            }
+        });
+        if (settingRegistry) {
+            try {
+                const settings = await settingRegistry.load(PLUGIN_ID);
+                const readSettings = () => {
+                    enabled = boolOption(settings.composite.enabled, true);
+                    notifyOnBell = boolOption(settings.composite.notifyOnBell, true);
+                };
+                readSettings();
+                settings.changed.connect(readSettings);
+            }
+            catch (reason) {
+                console.error('xtralab: failed to load terminal-notifications settings', reason);
+            }
+        }
+    }
+};
+// Run `fn`, swallowing errors so a malformed escape sequence cannot take the
+// terminal's parser or bell handler down with it.
+function guard(fn) {
+    try {
+        fn();
+    }
+    catch (reason) {
+        console.warn('xtralab: terminal notification handler failed', reason);
+    }
+}
+// `guard` for an OSC handler that reports whether it consumed the sequence.
+function guardOsc(fn) {
+    try {
+        return fn();
+    }
+    catch (reason) {
+        console.warn('xtralab: terminal notification handler failed', reason);
+        return false;
+    }
+}
+// Replace control characters with spaces (so a notification cannot carry escape
+// sequences), collapse whitespace, and clamp the length.
+function sanitize(value) {
+    var _a;
+    let result = '';
+    for (const char of value) {
+        const code = (_a = char.codePointAt(0)) !== null && _a !== void 0 ? _a : 0;
+        const isControl = code < 0x20 || (code >= 0x7f && code <= 0x9f);
+        result += isControl ? ' ' : char;
+    }
+    return result.replace(/\s+/g, ' ').trim().slice(0, MAX_TEXT_LENGTH);
+}
+function boolOption(value, fallback) {
+    return typeof value === 'boolean' ? value : fallback;
+}
+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;