@xingular/harness 1.0.0 → 1.2.0

package/dist/sdk/terminal/trajectory.js

@@ -15,7 +15,7 @@ export function listTerminalTrajectoryRuns(root, sessionId, nativeSessionId) {
     if (!nativeSessionId)
         return [];
     return listRuns(root, { sessionId })
-        .filter(run => run.nativeSessionId === nativeSessionId)
+        .filter(run => run.nativeSessionId === nativeSessionId || run.trigger === 'side-question' && run.sessionId === sessionId)
         .map(summary);
 }
 /** Read a run only when it belongs to both this terminal and its current native conversation. */
@@ -23,7 +23,7 @@ export function readTerminalTrajectory(root, sessionId, nativeSessionId, runId,
     if (!nativeSessionId || !Number.isSafeInteger(afterSequence ?? 0) || (afterSequence ?? 0) < 0)
         throw notFound('Run');
     const run = findRun(root, runId);
-    if (!run || run.sessionId !== sessionId || run.nativeSessionId !== nativeSessionId)
+    if (!run || run.sessionId !== sessionId || (run.nativeSessionId !== nativeSessionId && run.trigger !== 'side-question'))
         throw notFound('Run');
     const events = readEvents(root, runId).filter(event => afterSequence === undefined || event.sequence > afterSequence);
     return { run: summary(run), events };

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

@@ -0,0 +1,3 @@
+import type { AnnotateStart } from "./pages/annotatePage.js";
+/** `/annotate:annotate` accepts a page address, DevTools target, or page-bridge target. */
+export declare function parseAnnotate(argument: string): AnnotateStart | string;

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

@@ -0,0 +1,22 @@
+/** `/annotate:annotate` accepts a page address, DevTools target, or page-bridge target. */
+export function parseAnnotate(argument) {
+    const words = argument.trim().split(/\s+/).filter(Boolean);
+    if (!words.length)
+        return { kind: 'web' };
+    if (words[0] === '--app') {
+        const endpoint = words[1];
+        if (!endpoint)
+            return 'Give the app\'s DevTools address: /annotate:annotate --app http://127.0.0.1:9229';
+        const address = /^\d+$/.test(endpoint) ? `http://127.0.0.1:${endpoint}` : endpoint;
+        const name = words.slice(2).join(' ');
+        return { kind: 'cdp', endpoint: address, ...(name ? { name } : {}) };
+    }
+    if (words[0] === '--bridge') {
+        const name = words.slice(1).join(' ');
+        return { kind: 'bridge', ...(name ? { name } : {}) };
+    }
+    if (words.length > 1 || words[0].startsWith('--'))
+        return 'Use /annotate:annotate [url], /annotate:annotate --app <DevTools address>, or /annotate:annotate --bridge.';
+    const url = /^[a-z][a-z0-9+.-]*:\/\//i.test(words[0]) ? words[0] : /^(localhost|127\.0\.0\.1)(:\d+)?(\/|$)/.test(words[0]) ? `http://${words[0]}` : `https://${words[0]}`;
+    return { kind: 'web', url };
+}

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

@@ -1,7 +1,13 @@
 import type { TerminalPage } from "./page.js";
 import type { TerminalCommandHost } from "./commands.js";
-export type CommandPageId = 'doctor' | 'accounts' | 'permissions' | 'plugins' | 'hub' | 'components' | 'settings' | 'trajectory' | 'log';
+import { type AnnotateStart } from "./pages/annotatePage.js";
+export type CommandPageId = 'doctor' | 'accounts' | 'permissions' | 'plugins' | 'hub' | 'components' | 'settings' | 'trajectory' | 'log' | 'harness' | 'skills' | 'connections' | 'tools' | 'worktree' | 'notes' | 'annotate' | 'subagents' | 'agents' | 'usage';
 /** Construct one independent full-screen page for a slash command. */
 export declare function createCommandPage(host: TerminalCommandHost, id: CommandPageId, options?: {
     runId?: string;
+    url?: string;
+    annotate?: AnnotateStart;
+    usageTab?: 'analysis' | 'limit';
+    usagePeriod?: 'today' | '7d' | '30d' | 'all';
+    close?(): void;
 }): TerminalPage;

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

@@ -1,18 +1,24 @@
 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 { UsagePage } from "./pages/usagePage.js";
 import { createSettingsModel } from "./settingsModel.js";
 /** Construct one independent full-screen page for a slash command. */
 export function createCommandPage(host, id, options = {}) {
     const theme = () => host.ui.theme;
     const notify = (message, type) => host.ui.notify(message, type === 'error' || type === 'warning' ? type : 'info');
     switch (id) {
+        case 'usage':
+            return new UsagePage({ theme, call: host.control, changed: host.changed, initialTab: options.usageTab === 'limit' ? 'limits' : 'analysis', ...(options.usagePeriod ? { initialPeriod: options.usagePeriod } : {}) });
         case 'doctor':
             return new DoctorPage({ theme, call: host.control, confirm: host.ui.confirm.bind(host.ui), select: host.ui.select.bind(host.ui), changed: host.changed,
                 selection: () => {
@@ -34,12 +40,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 +91,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. */
@@ -11,9 +15,11 @@ export interface TerminalCommandHost {
     control: <T = unknown>(method: string, params?: Record<string, unknown>) => Promise<T>;
     ui: ExtensionUIContext;
     cwd(): string;
+    branch(): string | null;
     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,22 +27,22 @@ 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[];
     skills: () => SkillEntry[];
     expandSkill: (text: string) => string;
+    legacyAliases: () => string[];
 };

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

@@ -1,41 +1,34 @@
 import { isAbsolute, relative, resolve } from 'node:path';
 import { SessionManager } from '@earendil-works/pi-coding-agent';
+import { CORE_COMMANDS, coreCommand } from "../../commands/registry.js";
+import { commandRoutes, promptCommandAvailable } from "../../commands/routes.js";
+import { BUILTIN_PLUGIN_REGISTRY } from "../../plugins/builtin.js";
+import { pluginCommandPrefix } from "../../plugins/commandPrefix.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 { ResumeSessionsPage } from "./sessionPicker.js";
 import { expandSkillInvocation } from "./skillInvocation.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' }
-];
+import { groupTerminalCommands } from "../commandHelp.js";
+import { createBuiltinPluginCommandHandlers } from "./pluginCommands.js";
+export { parseAnnotate } from "./pluginCommands.js";
+const BUILTINS = CORE_COMMANDS.map((command) => ({
+    name: command.name,
+    ...('aliases' in command ? { aliases: [...command.aliases] } : {}),
+    description: command.description,
+    group: command.group
+}));
+const COMMAND_ALIASES = new Map(BUILTINS.flatMap(command => (command.aliases ?? []).map(alias => [alias, command.name])));
+const CORE_PROMPT_NAMES = new Set([...BUILTINS.map(command => command.name), ...COMMAND_ALIASES.keys()]);
+const LEGACY_BUILTIN_COMMAND_ALIASES = new Map([
+    ['doctor:doctor', 'doctor'], ['plugin:doctor', 'doctor'],
+    ['worktrees:worktree', 'worktree'], ['plugin:worktree', 'worktree'],
+    ['history:trajectory', 'trajectory'], ['plugin:trajectory', 'trajectory'],
+    ['subagents:subagents', 'subagents'], ['plugin:subagents', 'subagents'],
+    ['subagents:agents', 'agents'], ['plugin:agents', 'agents']
+]);
 export function createTerminalCommands(host) {
     const notify = (text) => host.ui.notify(text, 'info');
     const choose = async (title, items, label) => {
@@ -43,19 +36,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,31 +46,223 @@ 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 builtinPrefixes = new Map(pluginCommands.map(command => [command.prefix, command.pluginId]));
+    const prefixCache = new WeakMap();
+    const extensionCommands = () => {
+        return commandRoutes(host.session().extensionRunner.getRegisteredCommands().map(command => {
+            const source = command.sourceInfo;
+            let prefix = prefixCache.get(source);
+            if (!prefix) {
+                prefix = pluginCommandPrefix(source);
+                prefixCache.set(source, prefix);
+            }
+            const owner = source.origin === 'package'
+                ? `package:${source.baseDir ?? source.source}`
+                : `extension:${source.path}`;
+            return { ...command, prefix, owner, path: source.path };
+        }));
+    };
+    const coreCommandNames = (session) => new Set([
+        ...BUILTINS.flatMap(command => [command.name, ...(command.aliases ?? [])]),
+        ...session.resourceLoader.getPrompts().prompts.map(prompt => prompt.name)
+    ]);
+    const runBuiltinPluginCommand = async (command, argument) => {
+        try {
+            const handler = pluginHandlers.get(`${command.pluginId}:${command.name}`);
+            if (!handler)
+                throw new Error(`No terminal handler for built-in plugin command ${command.pluginId}:${command.name}.`);
+            await handler(argument);
+            host.refresh();
+        }
+        catch (error) {
+            host.ui.notify(error instanceof Error ? error.message : String(error), 'error');
+        }
+    };
+    const runExtensionCommand = async (registered, argument, route) => {
+        try {
+            const command = host.session().extensionRunner.getCommand(registered.invocationName);
+            if (!command)
+                throw new Error(`Plugin command /${route} 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');
+        }
+    };
+    const runLegacyPluginCommand = async (name, argument) => {
+        const session = host.session();
+        if (coreCommandNames(session).has(name)) {
+            host.ui.notify(`Use /${name}; /plugin:${name} is unavailable because a core command or prompt already uses that name.`, 'error');
+            return;
+        }
+        const builtins = BUILTIN_PLUGIN_REGISTRY.commandsNamed(name);
+        const extensions = extensionCommands();
+        if (builtins.length > 1) {
+            host.ui.notify(`Legacy plugin command /plugin:${name} is ambiguous. Use its owner-qualified command.`, 'error');
+            return;
+        }
+        if (builtins.length === 1) {
+            const competitors = extensions.byName.get(name) ?? [];
+            if (competitors.length) {
+                host.ui.notify(`Extension command /plugin:${name} from ${competitors.map(command => command.sourceInfo.path).join(', ')} is unavailable because the name belongs to the built-in ${builtins[0].pluginId} plugin.`, 'error');
+            }
+            await runBuiltinPluginCommand(builtins[0], argument);
+            return;
+        }
+        const matches = extensions.byName.get(name) ?? [];
+        if (matches.length > 1) {
+            host.ui.notify(`Legacy plugin command /plugin:${name} is ambiguous. Registered by: ${matches.map(command => command.sourceInfo.path).join(', ')}. Use its owner-qualified command.`, 'error');
+            return;
+        }
+        if (matches.length === 1) {
+            if (extensions.conflictingPrefixes.has(matches[0].prefix)) {
+                host.ui.notify(`Plugin prefix /${matches[0].prefix}: is ambiguous or reserved. Owners: ${extensions.conflictingPrefixes.get(matches[0].prefix).join(', ')}.`, 'error');
+                return;
+            }
+            await runExtensionCommand(matches[0], argument, `plugin:${name}`);
+            return;
+        }
+        host.ui.notify(`Unknown plugin command: /plugin:${name}. Use /help to list the commands.`, 'error');
+    };
+    const runNamespacedCommand = async (typedName, argument) => {
+        const separator = typedName.indexOf(':');
+        if (separator < 1)
+            return false;
+        const prefix = typedName.slice(0, separator);
+        const name = typedName.slice(separator + 1);
+        if (prefix === 'plugin') {
+            await runLegacyPluginCommand(name, argument);
+            return true;
+        }
+        const builtin = name ? BUILTIN_PLUGIN_REGISTRY.command(prefix, name) : BUILTIN_PLUGIN_REGISTRY.defaultCommand(prefix);
+        const extensions = extensionCommands();
+        const isBuiltinPrefix = builtinPrefixes.has(prefix);
+        const isExtensionPrefix = extensions.ownersByPrefix.has(prefix);
+        if (!builtin && !isBuiltinPrefix && !isExtensionPrefix)
+            return false;
+        if (builtin) {
+            const competitors = extensions.routes.get(`${prefix}:${builtin.name}`) ?? [];
+            if (competitors.length) {
+                host.ui.notify(`Extension command /${prefix}:${builtin.name} from ${competitors.map(command => command.sourceInfo.path).join(', ')} is unavailable because the prefix belongs to built-in ${builtin.pluginId}.`, 'error');
+            }
+            await runBuiltinPluginCommand(builtin, argument);
+            return true;
+        }
+        if (extensions.conflictingPrefixes.has(prefix)) {
+            host.ui.notify(`Plugin prefix /${prefix}: is ambiguous or reserved. Owners: ${extensions.conflictingPrefixes.get(prefix).join(', ')}.`, 'error');
+            return true;
+        }
+        if (!name) {
+            host.ui.notify(`Plugin /${prefix}: has no default command. Use /help to list its commands.`, 'error');
+            return true;
+        }
+        const matches = extensions.routes.get(`${prefix}:${name}`) ?? [];
+        if (matches.length > 1) {
+            host.ui.notify(`Plugin command /${prefix}:${name} is ambiguous. Registered by: ${matches.map(command => command.sourceInfo.path).join(', ')}.`, 'error');
+            return true;
+        }
+        if (matches.length === 1) {
+            await runExtensionCommand(matches[0], argument, `${prefix}:${name}`);
+            return true;
+        }
+        host.ui.notify(`Unknown plugin command: /${typedName}. Use /help to list the commands.`, 'error');
+        return true;
+    };
+    const legacyAliases = () => {
+        const session = host.session();
+        const coreNames = coreCommandNames(session);
+        const aliases = new Set(LEGACY_BUILTIN_COMMAND_ALIASES.keys());
+        for (const command of pluginCommands) {
+            if (coreNames.has(command.name))
+                continue;
+            aliases.add(`plugin:${command.name}`);
+            if (command.legacyBare)
+                aliases.add(command.name);
+        }
+        for (const name of extensionCommands().byName.keys()) {
+            if (!coreNames.has(name))
+                aliases.add(`plugin:${name}`);
+        }
+        return [...aliases];
+    };
+    const completions = () => {
+        const session = host.session();
+        const prompts = session.resourceLoader.getPrompts().prompts;
+        const commands = new Map(BUILTINS.map(command => [command.name, command]));
+        for (const command of pluginCommands) {
+            const invocation = `${command.prefix}:${command.name}`;
+            commands.set(invocation, { name: invocation, description: command.description, group: 'Plugins' });
+        }
+        for (const module of BUILTIN_PLUGIN_REGISTRY.modules) {
+            const defaultCommand = module.defaultCommand && BUILTIN_PLUGIN_REGISTRY.command(module.commandPrefix ?? module.descriptor.id, module.defaultCommand);
+            if (defaultCommand) {
+                const invocation = `${defaultCommand.prefix}:`;
+                commands.set(invocation, { name: invocation, description: defaultCommand.description, group: 'Plugins' });
+            }
+        }
+        const extensions = extensionCommands();
+        for (const [route, matches] of extensions.routes) {
+            const prefix = route.slice(0, route.indexOf(':'));
+            if (matches.length !== 1 || extensions.conflictingPrefixes.has(prefix))
+                continue;
+            if (BUILTIN_PLUGIN_REGISTRY.command(prefix, matches[0].name))
+                continue;
+            commands.set(route, { name: route, description: matches[0].description, group: 'Plugins' });
+        }
+        const extensionNames = new Set(extensions.byName.keys());
+        for (const prompt of prompts) {
+            if (promptCommandAvailable(prompt.name, new Set([...commands.keys(), ...COMMAND_ALIASES.keys()]), extensionNames))
+                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;
+        const legacyBuiltin = LEGACY_BUILTIN_COMMAND_ALIASES.get(typedName);
+        if (!legacyBuiltin && await runNamespacedCommand(typedName, argument))
+            return true;
+        const session = host.session();
+        const name = coreCommand(legacyBuiltin ?? typedName)?.name ?? legacyBuiltin ?? typedName;
+        const builtin = BUILTINS.find(item => item.name === name);
+        if (!builtin && !coreCommandNames(session).has(name)) {
+            const legacyBare = BUILTIN_PLUGIN_REGISTRY.commandsNamed(name).filter(command => command.legacyBare);
+            if (legacyBare.length > 1) {
+                host.ui.notify(`Legacy command /${name} is ambiguous. Use its owner-qualified command.`, 'error');
+                return true;
+            }
+            if (legacyBare.length === 1) {
+                await runBuiltinPluginCommand(legacyBare[0], 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;
+            const prompt = session.resourceLoader.getPrompts().prompts.some(item => item.name === name);
+            if (prompt && promptCommandAvailable(name, CORE_PROMPT_NAMES, new Set(extensionCommands().byName.keys())))
+                return false;
             host.ui.notify(`Unknown command: /${name}. Use /help to list commands.`, 'error');
             return true;
         }
         try {
-            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()))
@@ -105,7 +277,7 @@ export function createTerminalCommands(host) {
                     await host.btw(argument);
                     break;
                 case 'stop': {
-                    if (!session.isStreaming)
+                    if (session.isIdle)
                         throw new Error('Nothing is running.');
                     await host.runtime().interrupt();
                     break;
@@ -113,14 +285,24 @@ 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());
-                        const selected = await choose('Resume session', sessions, (item, index) => `${index + 1}. ${item.name ?? item.firstMessage ?? item.id}  ${item.modified.toLocaleString()}`);
+                        const selected = await host.ui.custom((tui, _theme, _keys, done) => {
+                            const page = new ResumeSessionsPage({
+                                theme: () => host.ui.theme,
+                                cwd: () => host.cwd(),
+                                branch: () => host.branch(),
+                                listSessions: signal => SessionManager.list(host.cwd(), host.sessionDirectory(), undefined, signal),
+                                select: done,
+                                cancel: () => done(undefined),
+                                changed: host.changed
+                            });
+                            return new PageOverlay({ page, tui, theme: () => host.ui.theme, close: () => done(undefined), changed: host.changed });
+                        }, { overlay: true, overlayOptions: pageOverlayOptions('fullscreen') });
                         if (!selected)
                             break;
-                        path = selected.path;
+                        path = selected;
                     }
                     const target = resolve(host.cwd(), path);
                     const within = relative(host.sessionDirectory(), target);
@@ -150,7 +332,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,11 +387,23 @@ export function createTerminalCommands(host) {
                         await session.setModel(selected.model, { persist: selected.persist });
                     break;
                 }
+                case 'settings':
+                    await openPage('settings');
+                    break;
                 case 'doctor':
                     await openPage('doctor');
                     break;
-                case 'settings':
-                    await openPage('settings');
+                case 'worktree':
+                    await openPage('worktree');
+                    break;
+                case 'trajectory':
+                    await openPage('trajectory', { runId: argument });
+                    break;
+                case 'subagents':
+                    await openPage('subagents');
+                    break;
+                case 'agents':
+                    await openPage('agents');
                     break;
                 case 'permissions':
                     await openPage('permissions');
@@ -217,6 +411,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 +439,6 @@ export function createTerminalCommands(host) {
                         session.setSessionName(name);
                     break;
                 }
-                case 'trajectory':
-                    await openPage('trajectory', { runId: argument });
-                    break;
                 case 'log':
                     await openPage('log');
                     break;
@@ -272,5 +476,5 @@ export function createTerminalCommands(host) {
         }
         return true;
     }
-    return { execute, completions, skills, expandSkill };
+    return { execute, completions, skills, expandSkill, legacyAliases };
 }

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;