@xingular/harness 1.0.0 → 1.1.1

package/dist/sdk/terminal/tui/commandPages.js

@@ -1,12 +1,15 @@
 import { DoctorPage } from "./pages/doctorPage.js";
 import { AccountsPage } from "./pages/accountsPage.js";
-import { ComponentsPage } from "./pages/componentsPage.js";
-import { HubPage } from "./pages/hubPage.js";
+import { BrowserPage } from "./pages/browserPage.js";
 import { LogPage, formatRunEventLog } from "./pages/logPage.js";
 import { PermissionsPage } from "./pages/permissionsPage.js";
-import { PluginsPage } from "./pages/pluginsPage.js";
 import { SettingsPage } from "./pages/settingsPage.js";
 import { TrajectoryPage } from "./pages/trajectoryPage.js";
+import { WorktreesPage } from "./pages/worktreesPage.js";
+import { NotesPage } from "./pages/notesPage.js";
+import { AnnotatePage } from "./pages/annotatePage.js";
+import { SubagentsPage } from "./pages/subagentsPage.js";
+import { AgentsPage } from "./pages/agentsPage.js";
 import { createSettingsModel } from "./settingsModel.js";
 /** Construct one independent full-screen page for a slash command. */
 export function createCommandPage(host, id, options = {}) {
@@ -34,12 +37,50 @@ export function createCommandPage(host, id, options = {}) {
                 activeTools: () => host.session().getActiveToolNames(),
                 confirm: (title, message) => host.ui.confirm(title, message), notify, changed: host.changed
             });
+        case 'harness':
+        case 'skills':
+        case 'connections':
+        case 'tools':
         case 'plugins':
-            return new PluginsPage({ theme, call: host.control, ui: host.ui, changed: host.changed });
         case 'hub':
-            return new HubPage({ theme, call: host.control, ui: host.ui, changed: host.changed });
         case 'components':
-            return new ComponentsPage({ theme, call: host.control, ui: host.ui, notify, changed: host.changed });
+            return new BrowserPage({
+                theme, call: host.control, changed: host.changed,
+                section: id === 'harness' || id === 'hub' ? 'overview' : id === 'components' ? 'library' : id,
+                source: id === 'hub' ? 'discover' : 'installed',
+                ui: {
+                    select: host.ui.select.bind(host.ui), confirm: host.ui.confirm.bind(host.ui), notify: host.ui.notify.bind(host.ui), input: host.ui.input.bind(host.ui),
+                    secretInput: (title, placeholder) => {
+                        const ui = host.ui;
+                        if (!ui.secretInput)
+                            throw new Error('Masked credential entry is unavailable in this host.');
+                        return ui.secretInput(title, placeholder);
+                    }
+                },
+                runtime: () => ({ skills: host.session().resourceLoader.getSkills().skills,
+                    tools: host.session().getAllTools(), activeTools: host.session().getActiveToolNames(), skillCommands: host.session().settingsManager.getEnableSkillCommands() }),
+                permissions: () => host.runtime().permissions(), setGlobalTool: (tool, allowed) => host.runtime().setGlobalTool(tool, allowed),
+                useSkill: name => {
+                    const draft = host.ui.getEditorText();
+                    host.setEditorText(`$${name}${draft ? ' ' + draft : ' '}`);
+                    options.close?.();
+                }
+            });
+        case 'worktree':
+            return new WorktreesPage({
+                theme, call: host.control, changed: host.changed, relaunch: host.shutdown,
+                ui: { select: host.ui.select.bind(host.ui), confirm: host.ui.confirm.bind(host.ui), notify: host.ui.notify.bind(host.ui), input: host.ui.input.bind(host.ui) }
+            });
+        case 'notes':
+            return new NotesPage({
+                theme, call: host.control, changed: host.changed, ...(options.url !== undefined ? { start: options.url ? { url: options.url } : {} } : {}),
+                ui: { select: host.ui.select.bind(host.ui), confirm: host.ui.confirm.bind(host.ui), notify: host.ui.notify.bind(host.ui), input: host.ui.input.bind(host.ui) }
+            });
+        case 'annotate':
+            return new AnnotatePage({
+                theme, call: host.control, changed: host.changed, start: options.annotate ?? { kind: 'web' },
+                ui: { select: host.ui.select.bind(host.ui), confirm: host.ui.confirm.bind(host.ui), notify: host.ui.notify.bind(host.ui), input: host.ui.input.bind(host.ui) }
+            });
         case 'settings':
             return new SettingsPage({ theme, ...createSettingsModel(host), notify, changed: host.changed });
         case 'trajectory':
@@ -47,6 +88,13 @@ export function createCommandPage(host, id, options = {}) {
                 theme, runs: host.trajectory.list, read: host.trajectory.read, copy: host.copyText,
                 initialRunId: options.runId || undefined, notify, changed: host.changed
             });
+        case 'subagents':
+            return new SubagentsPage({ theme, snapshot: host.subagents, changed: host.changed });
+        case 'agents':
+            return new AgentsPage({
+                theme, call: host.control, changed: host.changed, ...(host.editFile ? { edit: host.editFile.bind(host) } : {}),
+                ui: { select: host.ui.select.bind(host.ui), confirm: host.ui.confirm.bind(host.ui), notify: host.ui.notify.bind(host.ui), input: host.ui.input.bind(host.ui) }
+            });
         case 'log':
             return new LogPage({
                 theme, changed: host.changed,

package/dist/sdk/terminal/tui/commands.d.ts

@@ -2,6 +2,10 @@ import { type AgentSession, type ExtensionUIContext } from '@earendil-works/pi-c
 import { type SkillEntry } from "./skillInvocation.js";
 import type { TerminalRuntime } from "./runtime.js";
 import type { TerminalTrajectoryRun, TerminalTrajectorySnapshot } from "../trajectory.js";
+import type { TerminalSubagentActivity } from "../subagentMonitor.js";
+import { type TerminalCommandCompletion, type TerminalCommandHelpGroup } from "../commandHelp.js";
+export type { TerminalCommandCompletion } from "../commandHelp.js";
+export { parseAnnotate } from "./pluginCommands.js";
 export interface TerminalCommandHost {
     session(): AgentSession;
     /** Navigation is scope checked by the Harness runtime adapter. */
@@ -14,6 +18,7 @@ export interface TerminalCommandHost {
     sessionDirectory(): string;
     refresh(): void;
     changed(): void;
+    showHelp(groups: TerminalCommandHelpGroup[]): void;
     plan(brief: string): void;
     /** Asks a side question in its own tool-free session; empty text dismisses the one showing. */
     btw(question: string): Promise<void>;
@@ -21,19 +26,18 @@ export interface TerminalCommandHost {
     setEditorText(text: string): void;
     copyText(text: string): Promise<void>;
     suspend?(): Promise<void>;
+    /** Opens a file in the person's editor and resolves once the editor closes. */
+    editFile?(path: string): Promise<void>;
     hotkeys?(): string;
     logs: {
         read(): Promise<string>;
     };
+    subagents(): readonly TerminalSubagentActivity[];
     trajectory: {
         list(): Promise<TerminalTrajectoryRun[]>;
         read(runId: string, afterSequence?: number): Promise<TerminalTrajectorySnapshot>;
     };
 }
-export interface TerminalCommandCompletion {
-    name: string;
-    description?: string;
-}
 export declare function createTerminalCommands(host: TerminalCommandHost): {
     execute: (text: string) => Promise<boolean>;
     completions: () => TerminalCommandCompletion[];

package/dist/sdk/terminal/tui/commands.js

@@ -1,41 +1,49 @@
 import { isAbsolute, relative, resolve } from 'node:path';
 import { SessionManager } from '@earendil-works/pi-coding-agent';
+import { BUILTIN_PLUGIN_REGISTRY } from "../../plugins/builtin.js";
 import { PageOverlay } from "./pageOverlay.js";
 import { ModelPicker } from "./modelPicker.js";
 import { TreePicker } from "./treePicker.js";
 import { createCommandPage } from "./commandPages.js";
 import { pageOverlayOptions } from "./dialogGeometry.js";
 import { expandSkillInvocation } from "./skillInvocation.js";
+import { groupTerminalCommands } from "../commandHelp.js";
+import { createBuiltinPluginCommandHandlers } from "./pluginCommands.js";
+export { parseAnnotate } from "./pluginCommands.js";
 const BUILTINS = [
-    { name: 'doctor', description: 'Check account, model, tools and runtime readiness' },
-    { name: 'help', description: 'List the commands' },
-    { name: 'plan', description: 'Plan one request, read-only: /plan <brief>' },
-    { name: 'btw', description: 'Ask a side question without interrupting: /btw <question>' },
-    { name: 'new', description: 'Start a new session' },
-    { name: 'stop', description: 'Stop the current reply' },
-    { name: 'resume', description: 'Resume a session in this account and folder' },
-    { name: 'tree', description: 'Navigate the session tree' },
-    { name: 'fork', description: 'Fork from an earlier message' },
-    { name: 'clone', description: 'Clone this branch into a new session' },
-    { name: 'model', description: 'Choose the model' },
-    { name: 'effort', description: 'Choose the thinking effort' },
-    { name: 'thinking', description: 'Toggle transcript thinking visibility: /thinking [show|hide]' },
-    { name: 'name', description: 'Name this session' },
-    { name: 'compact', description: 'Compact the context' },
-    { name: 'copy', description: 'Copy the last reply' },
-    { name: 'export', description: 'Export this branch to HTML or JSONL' },
-    { name: 'reload', description: 'Reload trusted resources and keybindings' },
-    { name: 'accounts', description: 'Sign in, switch, check and remove Pi accounts' },
-    { name: 'permissions', description: 'Full Permission and per-tool approvals' },
-    { name: 'plugins', description: 'Switch plugins on or off and trust their code' },
-    { name: 'hub', description: 'Browse and install reviewed skills, plugins and documents' },
-    { name: 'components', description: 'Browse skills, prompts and rules for this Harness scope' },
-    { name: 'settings', description: 'Session and terminal settings' },
-    { name: 'trajectory', description: 'Inspect the recorded runs of this session' },
-    { name: 'log', description: "Harness diagnostics and this conversation's run events" },
-    { name: 'hotkeys', description: 'Keyboard controls' },
-    { name: 'quit', description: 'Restore the terminal and exit' }
+    { name: 'help', description: 'List the commands', group: 'Core' },
+    { name: 'plan', description: 'Plan one request, read-only: /plan <brief>', group: 'Run' },
+    { name: 'btw', aliases: ['side'], description: 'Ask a side question without interrupting: /btw <question>', group: 'Run' },
+    { name: 'new', description: 'Start a new session', group: 'Session' },
+    { name: 'stop', description: 'Stop the current reply', group: 'Run' },
+    { name: 'session', aliases: ['resume'], description: 'Choose a saved session in this account and folder', group: 'Session' },
+    { name: 'history', aliases: ['tree'], description: 'Navigate branches in the current session', group: 'Session' },
+    { name: 'fork', description: 'Fork from an earlier message', group: 'Session' },
+    { name: 'clone', description: 'Clone this branch into a new session', group: 'Session' },
+    { name: 'model', description: 'Choose the model', group: 'Model' },
+    { name: 'effort', description: 'Choose the thinking effort', group: 'Model' },
+    { name: 'thinking', description: 'Toggle transcript thinking visibility: /thinking [show|hide]', group: 'Model' },
+    { name: 'name', description: 'Name this session', group: 'Session' },
+    { name: 'compact', description: 'Compact the context', group: 'Session' },
+    { name: 'copy', description: 'Copy the last reply', group: 'Inspect' },
+    { name: 'export', description: 'Export this branch to HTML or JSONL', group: 'Inspect' },
+    { name: 'reload', description: 'Reload trusted resources and keybindings', group: 'Harness' },
+    { name: 'accounts', description: 'Sign in, switch, check and remove Pi accounts', group: 'Harness' },
+    { name: 'permissions', description: 'Full Permission and per-tool approvals', group: 'Harness' },
+    { name: 'harness', description: 'Browse foundation, variant and all resources', group: 'Harness' },
+    { name: 'skills', description: 'View, inspect and use skills; discover more', group: 'Harness' },
+    { name: 'connections', description: 'Manage local and remote MCP connections', group: 'Harness' },
+    { name: 'mcp', description: 'Open Connections in the Harness browser', group: 'Harness' },
+    { name: 'tools', description: 'Inspect available tools, owners and approvals', group: 'Harness' },
+    { name: 'plugins', description: 'Switch plugins on or off and trust their code', group: 'Harness' },
+    { name: 'hub', description: 'Browse and install reviewed skills, plugins and documents', group: 'Harness' },
+    { name: 'components', description: 'Browse skills, prompts and rules for this Harness scope', group: 'Harness' },
+    { name: 'settings', description: 'Session, terminal and browser settings', group: 'Harness' },
+    { name: 'log', description: "Harness diagnostics and this conversation's run events", group: 'Inspect' },
+    { name: 'hotkeys', description: 'Keyboard controls', group: 'Core' },
+    { name: 'quit', description: 'Restore the terminal and exit', group: 'Core' }
 ];
+const COMMAND_ALIASES = new Map(BUILTINS.flatMap(command => (command.aliases ?? []).map(alias => [alias, command.name])));
 export function createTerminalCommands(host) {
     const notify = (text) => host.ui.notify(text, 'info');
     const choose = async (title, items, label) => {
@@ -43,19 +51,6 @@ export function createTerminalCommands(host) {
         const selected = await host.ui.select(title, labels);
         return selected === undefined ? undefined : items[labels.indexOf(selected)];
     };
-    const completions = () => {
-        const session = host.session();
-        const commands = new Map(BUILTINS.map(command => [command.name, command]));
-        for (const command of session.extensionRunner.getRegisteredCommands()) {
-            if (!commands.has(command.name))
-                commands.set(command.name, { name: command.name, description: command.description });
-        }
-        for (const prompt of session.resourceLoader.getPrompts().prompts) {
-            if (!commands.has(prompt.name))
-                commands.set(prompt.name, { name: prompt.name, description: prompt.description });
-        }
-        return [...commands.values()];
-    };
     /** The skills this session may be asked to use, each invoked as `$name`. Off with the "Skill commands" setting. */
     const skills = () => {
         const session = host.session();
@@ -66,23 +61,144 @@ export function createTerminalCommands(host) {
     /** The text to send: a leading `$name` of a loaded skill becomes the `/skill:name` form Pi expands. */
     const expandSkill = (text) => expandSkillInvocation(text, new Set(skills().map((skill) => skill.name)));
     async function openPage(id, options = {}) {
-        await host.ui.custom((tui, _theme, _keys, done) => new PageOverlay({
-            page: createCommandPage(host, id, options), tui, theme: () => host.ui.theme,
-            close: () => done(undefined), changed: host.changed
-        }), { overlay: true, overlayOptions: pageOverlayOptions() });
+        let close = () => { };
+        const page = createCommandPage(host, id, { ...options, close: () => close() });
+        await host.ui.custom((tui, _theme, _keys, done) => {
+            close = () => done(undefined);
+            return new PageOverlay({ page, tui, theme: () => host.ui.theme, close, changed: host.changed });
+        }, { overlay: true, overlayOptions: pageOverlayOptions(page.presentation) });
     }
+    const pluginHandlers = createBuiltinPluginCommandHandlers(host, openPage);
+    const pluginCommands = BUILTIN_PLUGIN_REGISTRY.commands();
+    const coreNames = new Set([...BUILTINS.map(command => command.name), ...COMMAND_ALIASES.keys()]);
+    for (const command of pluginCommands) {
+        if (command.namespace === 'unprefixed' && coreNames.has(command.name)) {
+            throw new Error(`Required plugin command collides with a core command: ${command.pluginId}:${command.name}`);
+        }
+    }
+    const extensionCommands = () => {
+        const byName = new Map();
+        for (const command of host.session().extensionRunner.getRegisteredCommands()) {
+            byName.set(command.name, [...(byName.get(command.name) ?? []), command]);
+        }
+        const unique = new Map();
+        const duplicates = new Map();
+        for (const [name, commands] of byName) {
+            if (commands.length === 1)
+                unique.set(name, commands[0]);
+            else
+                duplicates.set(name, commands);
+        }
+        return { unique, duplicates };
+    };
+    const unprefixedCommandNames = (session) => new Set([
+        ...BUILTINS.flatMap(command => [command.name, ...(command.aliases ?? [])]),
+        ...pluginCommands.filter(command => command.namespace === 'unprefixed').map(command => command.name),
+        ...session.resourceLoader.getPrompts().prompts.map(prompt => prompt.name)
+    ]);
+    const runBuiltinPluginCommand = async (name, argument) => {
+        try {
+            const handler = pluginHandlers.get(name);
+            if (!handler)
+                throw new Error(`No terminal handler for built-in plugin command ${name}.`);
+            await handler(argument);
+            host.refresh();
+        }
+        catch (error) {
+            host.ui.notify(error instanceof Error ? error.message : String(error), 'error');
+        }
+    };
+    const completions = () => {
+        const session = host.session();
+        const prompts = session.resourceLoader.getPrompts().prompts;
+        const commands = new Map(BUILTINS.map(command => [command.name, command]));
+        const bareNames = unprefixedCommandNames(session);
+        const namespacedBuiltins = new Set();
+        for (const command of pluginCommands) {
+            if (command.namespace === 'unprefixed') {
+                commands.set(command.name, { name: command.name, description: command.description, group: 'Harness' });
+            }
+            else {
+                namespacedBuiltins.add(command.name);
+                if (!bareNames.has(command.name)) {
+                    const invocation = `plugin:${command.name}`;
+                    commands.set(invocation, { name: invocation, description: command.description, group: 'Plugins' });
+                }
+            }
+        }
+        const extensions = extensionCommands();
+        for (const [name, command] of extensions.unique) {
+            if (!bareNames.has(name) && !namespacedBuiltins.has(name)) {
+                const invocation = `plugin:${name}`;
+                commands.set(invocation, { name: invocation, description: command.description, group: 'Plugins' });
+            }
+        }
+        for (const prompt of prompts) {
+            if (!commands.has(prompt.name) && !COMMAND_ALIASES.has(prompt.name))
+                commands.set(prompt.name, { name: prompt.name, description: prompt.description, group: 'Prompts' });
+        }
+        return [...commands.values()];
+    };
     async function execute(text) {
         const match = /^\/([^\s]+)(?:\s+([\s\S]*))?$/.exec(text.trim());
         if (!match)
             return false;
-        const name = match[1];
+        const typedName = match[1];
         const argument = match[2]?.trim() ?? '';
-        if (!BUILTINS.some(item => item.name === name)) {
-            if (completions().some(item => item.name === name))
-                return false;
+        if (typedName.startsWith('plugin:')) {
+            const pluginName = typedName.slice('plugin:'.length);
+            const session = host.session();
+            if (unprefixedCommandNames(session).has(pluginName)) {
+                host.ui.notify(`Use /${pluginName}; /plugin:${pluginName} is unavailable because an unprefixed command already uses that name.`, 'error');
+                return true;
+            }
+            const builtin = BUILTIN_PLUGIN_REGISTRY.command(pluginName);
+            const extensions = extensionCommands();
+            if (builtin?.namespace === 'plugin') {
+                const collisions = extensions.unique.get(pluginName) ? [extensions.unique.get(pluginName)] : extensions.duplicates.get(pluginName) ?? [];
+                if (collisions.length) {
+                    const owners = collisions.map(command => command.sourceInfo.path).join(', ');
+                    host.ui.notify(`Extension command /plugin:${pluginName} from ${owners} is unavailable because the name belongs to the built-in ${builtin.pluginId} plugin.`, 'error');
+                }
+                await runBuiltinPluginCommand(pluginName, argument);
+                return true;
+            }
+            const duplicate = extensions.duplicates.get(pluginName);
+            if (duplicate) {
+                const owners = duplicate.map(command => command.sourceInfo.path).join(', ');
+                host.ui.notify(`Plugin command /plugin:${pluginName} is ambiguous. Registered by: ${owners}. Rename or remove one command.`, 'error');
+                return true;
+            }
+            const registered = extensions.unique.get(pluginName);
+            if (registered) {
+                try {
+                    const command = host.session().extensionRunner.getCommand(registered.invocationName);
+                    if (!command)
+                        throw new Error(`Plugin command /plugin:${pluginName} is no longer registered. Reload trusted resources.`);
+                    await command.handler(argument, host.session().extensionRunner.createCommandContext());
+                    host.refresh();
+                }
+                catch (error) {
+                    host.ui.notify(error instanceof Error ? error.message : String(error), 'error');
+                }
+                return true;
+            }
+            host.ui.notify(`Unknown plugin command: /${typedName}. Use /help to list the commands.`, 'error');
+            return true;
+        }
+        const name = COMMAND_ALIASES.get(typedName) ?? typedName;
+        const builtin = BUILTINS.find(item => item.name === name);
+        const requiredPluginCommand = BUILTIN_PLUGIN_REGISTRY.command(name);
+        if (!builtin && requiredPluginCommand?.namespace === 'unprefixed') {
+            await runBuiltinPluginCommand(name, argument);
+            return true;
+        }
+        if (!builtin) {
             // A skill is offered as $name; the typed /skill:name form still reaches the SDK, which expands it.
             if (skills().some(skill => `skill:${skill.name}` === name))
                 return false;
+            if (host.session().resourceLoader.getPrompts().prompts.some(prompt => prompt.name === name))
+                return false;
             host.ui.notify(`Unknown command: /${name}. Use /help to list commands.`, 'error');
             return true;
         }
@@ -90,7 +206,7 @@ export function createTerminalCommands(host) {
             const session = host.session();
             switch (name) {
                 case 'help':
-                    notify(completions().map(item => `/${item.name}  ${item.description ?? ''}`).join('\n'));
+                    host.showHelp(groupTerminalCommands(completions()));
                     break;
                 case 'plan': {
                     if (!argument || ['on', 'off', 'toggle'].includes(argument.toLowerCase()))
@@ -113,7 +229,7 @@ export function createTerminalCommands(host) {
                 case 'new':
                     await host.runtime().newSession();
                     break;
-                case 'resume': {
+                case 'session': {
                     let path = argument;
                     if (!path) {
                         const sessions = await SessionManager.list(host.cwd(), host.sessionDirectory());
@@ -150,7 +266,7 @@ export function createTerminalCommands(host) {
                     }
                     break;
                 }
-                case 'tree': {
+                case 'history': {
                     const tree = session.sessionManager.getTree();
                     if (!tree.length)
                         throw new Error('No entries in this session');
@@ -205,9 +321,6 @@ export function createTerminalCommands(host) {
                         await session.setModel(selected.model, { persist: selected.persist });
                     break;
                 }
-                case 'doctor':
-                    await openPage('doctor');
-                    break;
                 case 'settings':
                     await openPage('settings');
                     break;
@@ -217,6 +330,19 @@ export function createTerminalCommands(host) {
                 case 'accounts':
                     await openPage('accounts');
                     break;
+                case 'harness':
+                    await openPage('harness');
+                    break;
+                case 'skills':
+                    await openPage('skills');
+                    break;
+                case 'connections':
+                case 'mcp':
+                    await openPage('connections');
+                    break;
+                case 'tools':
+                    await openPage('tools');
+                    break;
                 case 'plugins':
                     await openPage('plugins');
                     break;
@@ -232,9 +358,6 @@ export function createTerminalCommands(host) {
                         session.setSessionName(name);
                     break;
                 }
-                case 'trajectory':
-                    await openPage('trajectory', { runId: argument });
-                    break;
                 case 'log':
                     await openPage('log');
                     break;

package/dist/sdk/terminal/tui/dialogGeometry.d.ts

@@ -23,5 +23,5 @@ export declare function centeredDialogHost(tui: TUI): boolean;
 export declare function pageRows(tui: TUI): number;
 /** Centers a rectangle on the screen, clamped so it never starts outside the terminal. */
 export declare function centeredRect(columns: number, rows: number, width: number, height: number): DialogRect;
-/** The overlay options every full-screen page command passes; OpenTUI reads the marker. */
-export declare function pageOverlayOptions(): HarnessOverlayOptions;
+/** Page commands declare their presentation; OpenTUI centers only marked dialogs. */
+export declare function pageOverlayOptions(presentation?: 'centered' | 'fullscreen'): HarnessOverlayOptions;

package/dist/sdk/terminal/tui/dialogGeometry.js

@@ -44,7 +44,9 @@ export function centeredRect(columns, rows, width, height) {
         height: boxHeight
     };
 }
-/** The overlay options every full-screen page command passes; OpenTUI reads the marker. */
-export function pageOverlayOptions() {
+/** Page commands declare their presentation; OpenTUI centers only marked dialogs. */
+export function pageOverlayOptions(presentation = 'centered') {
+    if (presentation === 'fullscreen')
+        return { anchor: 'top-left', width: '100%', maxHeight: '100%' };
     return { anchor: 'top-left', width: '100%', maxHeight: '100%', dialog: 'page' };
 }

package/dist/sdk/terminal/tui/dialogs.d.ts

@@ -1,6 +1,10 @@
 import type { ExtensionUIContext, ExtensionUIDialogOptions, KeybindingsManager, Theme } from '@earendil-works/pi-coding-agent';
 import { Input, type Component, type Focusable, type SelectListTheme, type TUI, type TuiMouseEventResult } from '@earendil-works/pi-tui';
 import type { TerminalMouseInput } from "./mouse.js";
+export interface GroupedSelectOption {
+    label: string;
+    group?: string;
+}
 /** `page` asks for a full-screen dialog; Pi's own dialogs ignore the field. */
 export type TerminalDialogOptions = ExtensionUIDialogOptions & {
     page?: boolean;
@@ -19,7 +23,7 @@ export declare class SearchableSelect implements Component, Focusable {
     private readonly list;
     private readonly labels;
     private focusedValue;
-    constructor(options: string[], tui: TUI, theme: () => Theme, select: (index: number) => void, cancel: () => void, search?: 'always' | 'never');
+    constructor(options: string[], tui: TUI, theme: () => Theme, select: (index: number) => void, cancel: () => void, search?: 'always' | 'never', groups?: readonly (string | undefined)[]);
     get focused(): boolean;
     set focused(value: boolean);
     get pinnedRows(): number;
@@ -66,6 +70,7 @@ export declare class TerminalDialogs {
     constructor(tui: TUI, theme: () => Theme, keybindings: KeybindingsManager, changed: () => void);
     private show;
     select(title: string, options: string[], opts?: TerminalDialogOptions): Promise<string | undefined>;
+    selectGrouped(title: string, options: readonly GroupedSelectOption[], opts?: ExtensionUIDialogOptions): Promise<string | undefined>;
     confirm(title: string, message: string, opts?: ExtensionUIDialogOptions): Promise<boolean>;
     input(title: string, placeholder?: string, opts?: ExtensionUIDialogOptions, secret?: boolean): Promise<string | undefined>;
     editor(title: string, prefill?: string): Promise<string | undefined>;

package/dist/sdk/terminal/tui/dialogs.js

@@ -31,14 +31,14 @@ export class SearchableSelect {
     list;
     labels;
     focusedValue = false;
-    constructor(options, tui, theme, select, cancel, search = 'always') {
+    constructor(options, tui, theme, select, cancel, search = 'always', groups) {
         this.tui = tui;
         this.select = select;
         this.cancel = cancel;
         this.labels = options.map(safe);
         this.list = new FilterList({
             theme, search,
-            rows: this.labels.map((label, index) => ({ id: String(index), label, data: index })),
+            rows: this.labels.map((label, index) => ({ id: String(index), label, ...(groups?.[index] ? { group: groups[index] } : {}), data: index })),
             limit: () => this.windowRows(),
             noun: ['option', 'options'],
             onActivate: row => this.select(row.data ?? 0),
@@ -265,6 +265,13 @@ export class TerminalDialogs {
             return new DialogPanel(title, list, this.theme, '↑/↓ select · Enter confirm · Esc cancel', undefined, opts?.page ? 'page' : 'block');
         }, opts);
     }
+    selectGrouped(title, options, opts) {
+        const labels = options.map(option => option.label);
+        return this.show(done => {
+            const list = new SearchableSelect(labels, this.tui, this.theme, index => done(labels[index]), () => done(undefined), 'always', options.map(option => option.group));
+            return new DialogPanel(title, list, this.theme, '↑/↓ select · Enter confirm · Esc cancel');
+        }, opts);
+    }
     async confirm(title, message, opts) {
         return (await this.show(done => {
             const list = new SearchableSelect(['Yes', 'No'], this.tui, this.theme, index => done(index === 0), () => done(undefined), 'never');

package/dist/sdk/terminal/tui/modelPicker.js

@@ -67,11 +67,8 @@ export class ModelPicker {
                 this.error = 'Model refresh timed out; showing cached models.';
             else if (result.errors.size)
                 this.error = `Could not refresh ${[...result.errors.keys()].join(', ')}; showing cached models.`;
-            else {
+            else
                 this.error = this.options.runtime.getError();
-                if (!this.error)
-                    this.status = 'Model catalogs refreshed.';
-            }
             this.load();
         }
         catch (error) {
@@ -135,10 +132,8 @@ export class ModelPicker {
             return [];
         const centered = centeredDialogHost(this.options.tui) && dialogFits(this.options.tui.terminal.columns, this.options.tui.terminal.rows);
         const inner = centered ? centerDialogContentWidth(width) : contentWidth(width);
-        const selected = this.list.selected?.data;
         const notes = [
             this.status ? theme.fg('muted', this.status) : '',
-            selected ? theme.fg('muted', `Model name: ${safeText(selected.name ?? selected.id)}`) : '',
             this.error ? theme.fg('error', this.error) : ''
         ].filter(Boolean);
         const chromeRows = centered ? centerDialogChromeRows(rows) : 4;

package/dist/sdk/terminal/tui/page.d.ts

@@ -2,6 +2,9 @@ import type { TuiMouseEventResult } from '@earendil-works/pi-tui';
 import type { TabInfo } from "./chrome.js";
 import type { TerminalMouseInput } from "./mouse.js";
 export interface TerminalPage {
+    presentation?: 'centered' | 'fullscreen';
+    ownsNavigation?: boolean;
+    selectTab?(id: string): void;
     tabs(): readonly TabInfo[];
     activeTab(): string;
     render(width: number, rows: number): string[];

package/dist/sdk/terminal/tui/pageOverlay.js

@@ -23,6 +23,12 @@ export class PageOverlay {
         if (this.disposed)
             return undefined;
         if (event.type === 'wheel') {
+            const layout = this.pointerLayout;
+            if (layout && event.y >= layout.bodyStart) {
+                const handled = this.page.handleMouse?.({ ...event, x: event.x - layout.contentX, y: event.y - layout.bodyStart });
+                if (handled?.handled)
+                    return handled;
+            }
             const key = event.wheelDelta !== undefined && event.wheelDelta < 0 ? '\x1b[5~' : '\x1b[6~';
             this.handleInput(key);
             return { handled: true, render: true };
@@ -49,6 +55,11 @@ export class PageOverlay {
             const target = tabIndex ?? (tabX < layout.contentWidth / 2
                 ? (current - 1 + tabs.length) % tabs.length
                 : (current + 1) % tabs.length);
+            if (this.page.selectTab) {
+                this.page.selectTab(tabs[target].id);
+                this.hoveredTab = undefined;
+                return { handled: true, render: true };
+            }
             const delta = (target - Math.max(0, current) + tabs.length) % tabs.length;
             const reverse = (Math.max(0, current) - target + tabs.length) % tabs.length;
             const direction = delta <= reverse ? '\t' : '\x1b[Z';
@@ -75,9 +86,9 @@ export class PageOverlay {
             this.options.close();
             return;
         }
-        const centered = centeredDialogHost(this.options.tui) && dialogFits(this.options.tui.terminal.columns, this.options.tui.terminal.rows);
+        const centered = this.page.presentation !== 'fullscreen' && centeredDialogHost(this.options.tui) && dialogFits(this.options.tui.terminal.columns, this.options.tui.terminal.rows);
         const tabs = this.options.page.tabs();
-        const input = centered && tabs.length > 1
+        const input = centered && tabs.length > 1 && !this.options.page.ownsNavigation
             ? matchesKey(data, 'right') ? '\t' : matchesKey(data, 'left') ? '\x1b[Z' : data
             : data;
         if (this.options.page.handleInput(input)) {
@@ -90,13 +101,13 @@ export class PageOverlay {
     render(width) {
         if (this.disposed)
             return [];
-        const rows = pageRows(this.options.tui);
+        const rows = this.page.presentation === 'fullscreen' ? this.options.tui.terminal.rows : pageRows(this.options.tui);
         const page = this.options.page;
         const tabs = page.tabs();
         if (width < 1 || rows < 1 || !tabs.length)
             return [];
         const theme = this.options.theme();
-        const centered = centeredDialogHost(this.options.tui) && dialogFits(this.options.tui.terminal.columns, this.options.tui.terminal.rows);
+        const centered = this.page.presentation !== 'fullscreen' && centeredDialogHost(this.options.tui) && dialogFits(this.options.tui.terminal.columns, this.options.tui.terminal.rows);
         const inner = centered ? centerDialogContentWidth(width) : contentWidth(width);
         if (centered) {
             const tabRows = tabs.length > 1 ? 1 : 0;
@@ -121,9 +132,9 @@ export class PageOverlay {
             contentWidth: contentWidth(width),
             centered
         };
-        const footer = [
+        const footer = page.ownsNavigation ? `Esc back/close · ${page.hint()}` : [
             page.hint(),
-            tabs.length > 1 ? 'Tab/Shift+Tab sections' : '',
+            tabs.length > 1 && !page.ownsNavigation ? 'Tab/Shift+Tab sections' : '',
             'Esc close'
         ].filter(Boolean).join(' · ');
         return pageFrame({