dexto 1.3.0 → 1.5.0

package/dist/cli/commands/interactive-commands/command-parser.js

@@ -1,19 +1,4 @@
 import chalk from 'chalk';
-/**
- * Helper for command handlers to get the current session ID from CLI context.
- * This is set by executeCommand() when invoked from InkCLI.
- *
- * Maintains separation of concerns:
- * - InkCLI state manages current sessionId
- * - executeCommand() stores it temporarily on agent for command access
- * - Commands use this helper instead of removed agent.getCurrentSessionId()
- *
- * @param agent - DextoAgent instance with __cliSessionId set by executeCommand
- * @returns Current session ID from CLI context, or null if not available
- */
-export function getCLISessionId(agent) {
-    return agent.__cliSessionId || null;
-}
 /**
  * Parse arguments respecting quotes and escape sequences
  */
@@ -105,12 +90,12 @@ export function getCommandSuggestions(partial, commands) {
 export function formatCommandHelp(cmd, detailed = false) {
     let help = chalk.cyan(`/${cmd.name}`) + ' - ' + cmd.description;
     if (detailed) {
-        help += '\n' + chalk.dim(`Usage: ${cmd.usage}`);
+        help += '\n' + chalk.gray(`Usage: ${cmd.usage}`);
         if (cmd.aliases && cmd.aliases.length > 0) {
-            help += '\n' + chalk.dim(`Aliases: ${cmd.aliases.map((a) => `/${a}`).join(', ')}`);
+            help += '\n' + chalk.gray(`Aliases: ${cmd.aliases.map((a) => `/${a}`).join(', ')}`);
         }
         if (cmd.subcommands && cmd.subcommands.length > 0) {
-            help += '\n' + chalk.dim('Subcommands:');
+            help += '\n' + chalk.gray('Subcommands:');
             for (const sub of cmd.subcommands) {
                 help += '\n  ' + chalk.cyan(`/${cmd.name} ${sub.name}`) + ' - ' + sub.description;
             }
@@ -150,7 +135,7 @@ export function displayAllCommands(commands) {
     for (const category of categoryOrder) {
         const cmds = categories[category];
         if (cmds && cmds.length > 0) {
-            console.log(chalk.bold.yellow(`${category}:`));
+            console.log(chalk.bold.rgb(255, 165, 0)(`${category}:`));
             for (const cmd of cmds) {
                 console.log('  ' + formatCommandHelp(cmd));
             }
@@ -160,13 +145,13 @@ export function displayAllCommands(commands) {
     // Display any uncategorized commands (fallback)
     for (const [category, cmds] of Object.entries(categories)) {
         if (!categoryOrder.includes(category) && cmds.length > 0) {
-            console.log(chalk.bold.yellow(`${category}:`));
+            console.log(chalk.bold.rgb(255, 165, 0)(`${category}:`));
             for (const cmd of cmds) {
                 console.log('  ' + formatCommandHelp(cmd));
             }
             console.log();
         }
     }
-    console.log(chalk.dim('💡 Tip: Use /help <command> for detailed help on any command'));
-    console.log(chalk.dim('💡 Tip: Type your message normally (without /) to chat with the AI\n'));
+    console.log(chalk.gray('💡 Tip: Use /help <command> for detailed help on any command'));
+    console.log(chalk.gray('💡 Tip: Type your message normally (without /) to chat with the AI\n'));
 }

package/dist/cli/commands/interactive-commands/commands.d.ts

@@ -18,8 +18,8 @@
  * This file serves as the integration layer that combines all modular commands
  * into a single CLI_COMMANDS array for the command execution system.
  */
-import { type DextoAgent } from '@dexto/core';
-import type { CommandDefinition } from './command-parser.js';
+import type { DextoAgent } from '@dexto/core';
+import type { CommandDefinition, CommandHandlerResult } from './command-parser.js';
 /**
  * Complete list of all available CLI commands.
  * This array combines commands from all extracted modules to maintain
@@ -40,9 +40,9 @@ export declare const CLI_COMMANDS: CommandDefinition[];
  * Execute a slash command
  *
  * @param sessionId - Session ID to use for agent.run() calls
- * @returns boolean indicating if command was handled, or string for ink-cli output
+ * @returns CommandHandlerResult - boolean, string, or StyledOutput
  */
-export declare function executeCommand(command: string, args: string[], agent: DextoAgent, sessionId?: string): Promise<boolean | string>;
+export declare function executeCommand(command: string, args: string[], agent: DextoAgent, sessionId?: string): Promise<CommandHandlerResult>;
 /**
  * Get all available command definitions
  * This is used by external systems that need to inspect available commands

package/dist/cli/commands/interactive-commands/commands.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"commands.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/interactive-commands/commands.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,EAAU,KAAK,UAAU,EAAE,MAAM,aAAa,CAAC;AACtD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAY7D;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,YAAY,EAAE,iBAAiB,EAAO,CAAC;AAsCpD;;;;;GAKG;AACH,wBAAsB,cAAc,CAChC,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,MAAM,EAAE,EACd,KAAK,EAAE,UAAU,EACjB,SAAS,CAAC,EAAE,MAAM,GACnB,OAAO,CAAC,OAAO,GAAG,MAAM,CAAC,CA0D3B;AAED;;;GAGG;AACH,wBAAgB,cAAc,IAAI,iBAAiB,EAAE,CAEpD"}
+{"version":3,"file":"commands.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/interactive-commands/commands.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAC9C,OAAO,KAAK,EAAE,iBAAiB,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAYnF;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,YAAY,EAAE,iBAAiB,EAAO,CAAC;AAqCpD;;;;;GAKG;AACH,wBAAsB,cAAc,CAChC,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,MAAM,EAAE,EACd,KAAK,EAAE,UAAU,EACjB,SAAS,CAAC,EAAE,MAAM,GACnB,OAAO,CAAC,oBAAoB,CAAC,CAyD/B;AAED;;;GAGG;AACH,wBAAgB,cAAc,IAAI,iBAAiB,EAAE,CAEpD"}

package/dist/cli/commands/interactive-commands/commands.js

@@ -18,7 +18,6 @@
  * This file serves as the integration layer that combines all modular commands
  * into a single CLI_COMMANDS array for the command execution system.
  */
-import { logger } from '@dexto/core';
 // Import modular command definitions
 import { generalCommands, createHelpCommand } from './general-commands.js';
 import { searchCommand, resumeCommand } from './session/index.js';
@@ -45,18 +44,17 @@ import { documentationCommands } from './documentation-commands.js';
  */
 export const CLI_COMMANDS = [];
 // Build the commands array with proper help command that can access all commands
-// Note: Interactive CLI uses simplified commands (interactive selectors instead of subcommands)
-// Regular CLI (headless) has full subcommand access via `dexto session list`, etc.
+// All commands here use interactive overlays - no text-based subcommands
 const baseCommands = [
     // General commands (without help)
     ...generalCommands,
-    // Session management - simplified for interactive CLI
-    searchCommand, // /search - search across sessions
-    resumeCommand, // /resume - show interactive selector (no /session subcommands)
-    // Model management - simplified for interactive CLI
-    modelCommands, // /model - show interactive selector (subcommands available but not emphasized)
-    // MCP server management commands
-    mcpCommands,
+    // Session management
+    searchCommand, // /search - opens search overlay
+    resumeCommand, // /resume - opens session selector overlay
+    // Model management
+    modelCommands, // /model - opens model selector overlay
+    // MCP server management
+    mcpCommands, // /mcp - opens MCP server list overlay
     // Tool management commands
     ...toolCommands,
     // Prompt management commands
@@ -74,60 +72,54 @@ CLI_COMMANDS.push(...baseCommands);
  * Execute a slash command
  *
  * @param sessionId - Session ID to use for agent.run() calls
- * @returns boolean indicating if command was handled, or string for ink-cli output
+ * @returns CommandHandlerResult - boolean, string, or StyledOutput
  */
 export async function executeCommand(command, args, agent, sessionId) {
-    // Store sessionId in agent context for command handlers to access
-    if (sessionId) {
-        agent.__cliSessionId = sessionId;
-    }
+    // Create command context with sessionId
+    const ctx = { sessionId: sessionId ?? null };
     // Find the command (including aliases)
     const cmd = CLI_COMMANDS.find((c) => c.name === command || (c.aliases && c.aliases.includes(command)));
     if (cmd) {
         try {
-            // Execute the handler with error handling
-            const result = await cmd.handler(args, agent);
+            // Execute the handler with context
+            const result = await cmd.handler(args, agent, ctx);
             // If handler returns a string, it's formatted output for ink-cli
             // If it returns boolean, it's the old behavior (handled or not)
             return result;
         }
         catch (error) {
             const errorMsg = `❌ Error executing command /${command}:\n${error instanceof Error ? error.message : String(error)}`;
-            console.error(errorMsg);
+            agent.logger.error(`Error executing command /${command}: ${error instanceof Error ? error.message : String(error)}`);
             return errorMsg; // Return for ink-cli
         }
     }
-    // Command not found in static commands - check if it's a prompt
+    // Command not found in static commands - check if it's a dynamic prompt command
+    // Dynamic commands use displayName (e.g., "quick-start" instead of "config:quick-start")
     try {
-        const hasPrompt = await agent.hasPrompt(command);
-        if (hasPrompt) {
-            // Import prompt command creation dynamically to avoid circular dependencies
-            const { getDynamicPromptCommands } = await import('./prompt-commands.js');
-            const dynamicCommands = await getDynamicPromptCommands(agent);
-            const promptCmd = dynamicCommands.find((c) => c.name === command);
-            if (promptCmd) {
-                try {
-                    const result = await promptCmd.handler(args, agent);
-                    // If result is a string, return it (for ink-cli display)
-                    // If result is boolean true, return empty string (command handled, message shown via agent.run())
-                    // If result is boolean false, return empty string (command handled)
-                    return typeof result === 'string' ? result : '';
-                }
-                catch (error) {
-                    const errorMsg = `❌ Error executing prompt /${command}:\n${error instanceof Error ? error.message : String(error)}`;
-                    console.error(errorMsg);
-                    return errorMsg;
-                }
+        // Import prompt command creation dynamically to avoid circular dependencies
+        const { getDynamicPromptCommands } = await import('./prompt-commands.js');
+        const dynamicCommands = await getDynamicPromptCommands(agent);
+        // Commands are registered by displayName, so search by command name directly
+        const promptCmd = dynamicCommands.find((c) => c.name === command);
+        if (promptCmd) {
+            try {
+                const result = await promptCmd.handler(args, agent, ctx);
+                // Return the result directly - can be string, boolean, StyledOutput, or SendMessageMarker
+                return result;
+            }
+            catch (error) {
+                const errorMsg = `❌ Error executing prompt /${command}:\n${error instanceof Error ? error.message : String(error)}`;
+                agent.logger.error(`Error executing prompt /${command}: ${error instanceof Error ? error.message : String(error)}`);
+                return errorMsg;
             }
         }
     }
     catch (error) {
-        // If checking for prompt fails, continue to unknown command error
-        logger.debug(`Failed to check if ${command} is a prompt: ${error instanceof Error ? error.message : String(error)}`);
+        // If loading dynamic commands fails, continue to unknown command error
+        agent.logger.debug(`Failed to check dynamic commands for ${command}: ${error instanceof Error ? error.message : String(error)}`);
     }
     // Command not found and not a prompt
-    const errorMsg = `❌ Unknown command: /${command}\nType /help to see available commands`;
-    console.log(errorMsg);
+    const errorMsg = `❌ Unknown command: /${command}\nType / to see available commands, /prompts to add new ones`;
     return errorMsg; // Return for ink-cli
 }
 /**

package/dist/cli/commands/interactive-commands/documentation-commands.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"documentation-commands.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/interactive-commands/documentation-commands.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAIH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAG7D;;GAEG;AACH,eAAO,MAAM,qBAAqB,EAAE,iBAAiB,EA8BpD,CAAC"}
+{"version":3,"file":"documentation-commands.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/interactive-commands/documentation-commands.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAGH,OAAO,KAAK,EAAE,iBAAiB,EAAkB,MAAM,qBAAqB,CAAC;AAG7E;;GAEG;AACH,eAAO,MAAM,qBAAqB,EAAE,iBAAiB,EAkCpD,CAAC"}

package/dist/cli/commands/interactive-commands/documentation-commands.js

@@ -7,7 +7,6 @@
  * Available Documentation Commands:
  * - /docs, /doc - Open Dexto documentation in browser
  */
-import chalk from 'chalk';
 import { CommandOutputHelper } from './utils/command-output.js';
 /**
  * Documentation commands
@@ -19,11 +18,10 @@ export const documentationCommands = [
         usage: '/docs',
         category: 'Documentation',
         aliases: ['doc'],
-        handler: async (_args, _agent) => {
+        handler: async (_args, _agent, _ctx) => {
             const docsUrl = 'https://docs.dexto.ai/docs/category/getting-started';
             try {
                 const { spawn } = await import('child_process');
-                console.log(chalk.blue(`🌐 Opening Dexto documentation: ${docsUrl}`));
                 // Cross-platform browser opening
                 const command = process.platform === 'darwin'
                     ? 'open'
@@ -31,11 +29,10 @@ export const documentationCommands = [
                         ? 'start'
                         : 'xdg-open';
                 spawn(command, [docsUrl], { detached: true, stdio: 'ignore' });
-                return CommandOutputHelper.success('✅ Documentation opened in browser');
+                return true; // Silent success
             }
-            catch (error) {
-                console.log(chalk.yellow(`💡 You can manually visit: ${docsUrl}`));
-                return CommandOutputHelper.error(error, 'Failed to open documentation');
+            catch {
+                return CommandOutputHelper.error(new Error(`Could not open browser. Visit: ${docsUrl}`), 'Failed to open documentation');
             }
         },
     },

package/dist/cli/commands/interactive-commands/general-commands.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"general-commands.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/interactive-commands/general-commands.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAIH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAI7D;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,cAAc,EAAE,MAAM,iBAAiB,EAAE,GAAG,iBAAiB,CA0I9F;AAED;;;GAGG;AACH,eAAO,MAAM,eAAe,EAAE,iBAAiB,EAkC9C,CAAC"}
+{"version":3,"file":"general-commands.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/interactive-commands/general-commands.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAIH,OAAO,KAAK,EAAE,iBAAiB,EAAwC,MAAM,qBAAqB,CAAC;AAMnG;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,cAAc,EAAE,MAAM,iBAAiB,EAAE,GAAG,iBAAiB,CAgC9F;AAED;;;GAGG;AACH,eAAO,MAAM,eAAe,EAAE,iBAAiB,EAiM9C,CAAC"}

package/dist/cli/commands/interactive-commands/general-commands.js

@@ -10,9 +10,9 @@
  * - /clear, /reset - Clear conversation history
  */
 import chalk from 'chalk';
-import { logger } from '@dexto/core';
-import { displayAllCommands, formatCommandHelp } from './command-parser.js';
 import { formatForInkCli } from './utils/format-output.js';
+import { CommandOutputHelper } from './utils/command-output.js';
+import { writeToClipboard } from '../../ink-cli/utils/clipboardUtils.js';
 /**
  * Creates the help command with access to all commands for display
  */
@@ -20,113 +20,25 @@ export function createHelpCommand(getAllCommands) {
     return {
         name: 'help',
         description: 'Show help information',
-        usage: '/help [command]',
+        usage: '/help',
         category: 'General',
         aliases: ['h', '?'],
-        handler: async (args, _agent) => {
+        handler: async (_args, _agent, _ctx) => {
             const allCommands = getAllCommands();
-            if (args.length === 0) {
-                // Build output string for ink-cli
-                const outputLines = ['\n📋 Available Commands:\n'];
-                // Define category order for consistent display
-                const categoryOrder = [
-                    'General',
-                    'MCP Management',
-                    'Tool Management',
-                    'Prompt Management',
-                    'System',
-                    'Documentation',
-                ];
-                const categories = {};
-                // Initialize categories
-                for (const category of categoryOrder) {
-                    categories[category] = [];
-                }
-                // Categorize commands using metadata
-                for (const cmd of allCommands) {
-                    const category = cmd.category || 'General';
-                    if (!categories[category]) {
-                        categories[category] = [];
-                    }
-                    categories[category].push(cmd);
-                }
-                // Build output by category in order
-                for (const category of categoryOrder) {
-                    const cmds = categories[category];
-                    if (cmds && cmds.length > 0) {
-                        outputLines.push(`${category}:`);
-                        for (const cmd of cmds) {
-                            const help = formatCommandHelp(cmd, false);
-                            outputLines.push('  ' + formatForInkCli(help));
-                        }
-                        outputLines.push('');
-                    }
-                }
-                // Display any uncategorized commands (fallback)
-                for (const [category, cmds] of Object.entries(categories)) {
-                    if (!categoryOrder.includes(category) && cmds.length > 0) {
-                        outputLines.push(`${category}:`);
-                        for (const cmd of cmds) {
-                            const help = formatCommandHelp(cmd, false);
-                            outputLines.push('  ' + formatForInkCli(help));
-                        }
-                        outputLines.push('');
-                    }
-                }
-                outputLines.push('💡 Tips:');
-                outputLines.push('   • Type your message normally (without /) to chat with the AI');
-                outputLines.push('   • Use /<prompt-name> to execute any listed prompt directly');
-                outputLines.push('   • Use /clear to start a new session (preserves old)');
-                outputLines.push('   • Press Ctrl+M to switch models, Ctrl+R to switch sessions');
-                outputLines.push('   • Use /search <query> to search across all sessions\n');
-                const output = outputLines.join('\n');
-                // Log for regular CLI (with chalk formatting)
-                displayAllCommands(allCommands);
-                return formatForInkCli(output);
-            }
-            const commandName = args[0];
-            if (!commandName) {
-                const output = '❌ No command specified';
-                console.log(chalk.red(output));
-                return formatForInkCli(output);
-            }
-            // Find the specific command to show detailed help
-            const cmd = allCommands.find((c) => c.name === commandName || (c.aliases && c.aliases.includes(commandName)));
-            if (cmd) {
-                const helpText = formatCommandHelp(cmd, true);
-                console.log(helpText);
-                return formatForInkCli(helpText);
-            }
-            // Redirect to contextual help for commands that have their own help subcommands
-            let output;
-            if (commandName === 'session') {
-                output =
-                    '💡 For detailed session help, use:\n   /session help\n\n   This shows all session subcommands with examples and tips.';
-                console.log(chalk.blue('💡 For detailed session help, use:'));
-                console.log(`   ${chalk.cyan('/session help')}`);
-                console.log(chalk.dim('\n   This shows all session subcommands with examples and tips.'));
-                return formatForInkCli(output);
-            }
-            if (commandName === 'model' || commandName === 'm') {
-                output =
-                    '💡 For detailed model help, use:\n   /model help\n\n   This shows all model subcommands with examples and usage.';
-                console.log(chalk.blue('💡 For detailed model help, use:'));
-                console.log(`   ${chalk.cyan('/model help')}`);
-                console.log(chalk.dim('\n   This shows all model subcommands with examples and usage.'));
-                return formatForInkCli(output);
-            }
-            if (commandName === 'mcp') {
-                output =
-                    '💡 For detailed MCP help, use:\n   /mcp help\n\n   This shows all MCP subcommands with examples and usage.';
-                console.log(chalk.blue('💡 For detailed MCP help, use:'));
-                console.log(`   ${chalk.cyan('/mcp help')}`);
-                console.log(chalk.dim('\n   This shows all MCP subcommands with examples and usage.'));
-                return formatForInkCli(output);
+            // Build styled data for help
+            const styledData = {
+                commands: allCommands.map((cmd) => ({
+                    name: cmd.name,
+                    description: cmd.description,
+                    category: cmd.category || 'General',
+                })),
+            };
+            // Build fallback text
+            const fallbackLines = ['Available Commands:'];
+            for (const cmd of allCommands) {
+                fallbackLines.push(`  /${cmd.name} - ${cmd.description}`);
             }
-            output = `❓ No help available for: ${commandName}\nUse /help to see all available commands`;
-            console.log(chalk.yellow(`❓ No help available for: ${commandName}`));
-            console.log(chalk.dim('Use /help to see all available commands'));
-            return formatForInkCli(output);
+            return CommandOutputHelper.styled('help', styledData, fallbackLines.join('\n'));
         },
     };
 }
@@ -141,31 +53,161 @@ export const generalCommands = [
         usage: '/exit',
         category: 'General',
         aliases: ['quit', 'q'],
-        handler: async (_args, _agent) => {
-            logger.warn('Exiting AI CLI. Goodbye!');
+        handler: async (_args, _agent, _ctx) => {
+            console.log(chalk.rgb(255, 165, 0)('Exiting AI CLI. Goodbye!'));
             process.exit(0);
         },
     },
     {
         name: 'clear',
-        description: 'Start a new session (clears viewable history without deleting)',
+        description: 'Clear context window (history preserved in DB, not sent to LLM)',
         usage: '/clear',
         category: 'General',
         aliases: ['new'],
-        handler: async (_args, agent) => {
+        handler: async (_args, agent, ctx) => {
             try {
-                // Create a new session instead of deleting history
-                // This clears the viewable conversation without deleting the old session
-                const newSession = await agent.createSession();
-                const output = `🔄 Started new session: ${newSession.id.slice(0, 8)}\n💡 Previous session preserved. Use /resume to switch back.`;
-                console.log(chalk.green(output));
-                return formatForInkCli(output);
+                const { sessionId } = ctx;
+                if (!sessionId) {
+                    return formatForInkCli('⚠️  No active session to clear');
+                }
+                // Clear context window - adds a marker so filterCompacted skips prior messages
+                // History stays in DB for review, but LLM won't see it
+                await agent.clearContext(sessionId);
+                return formatForInkCli('🔄 Context cleared\n💡 Previous messages preserved in history but not sent to LLM.');
             }
             catch (error) {
-                const errorMsg = `Failed to start new session: ${error instanceof Error ? error.message : String(error)}`;
-                logger.error(errorMsg);
+                const errorMsg = `Failed to clear context: ${error instanceof Error ? error.message : String(error)}`;
+                agent.logger.error(errorMsg);
                 return formatForInkCli(`❌ ${errorMsg}`);
             }
         },
     },
+    {
+        name: 'copy',
+        description: 'Copy the last assistant response to clipboard',
+        usage: '/copy',
+        category: 'General',
+        aliases: ['cp'],
+        handler: async (_args, agent, ctx) => {
+            try {
+                const { sessionId } = ctx;
+                if (!sessionId) {
+                    return formatForInkCli('❌ No active session');
+                }
+                // Get session history
+                const history = await agent.getSessionHistory(sessionId);
+                if (!history || history.length === 0) {
+                    return formatForInkCli('❌ No messages in current session');
+                }
+                // Find the last assistant message
+                const lastAssistantMessage = [...history]
+                    .reverse()
+                    .find((msg) => msg.role === 'assistant');
+                if (!lastAssistantMessage) {
+                    return formatForInkCli('❌ No assistant response to copy');
+                }
+                // Extract text content from the message
+                let textContent = '';
+                if (typeof lastAssistantMessage.content === 'string') {
+                    textContent = lastAssistantMessage.content;
+                }
+                else if (Array.isArray(lastAssistantMessage.content)) {
+                    // Handle multi-part content
+                    textContent = lastAssistantMessage.content
+                        .filter((part) => part.type === 'text')
+                        .map((part) => part.text)
+                        .join('\n');
+                }
+                if (!textContent) {
+                    return formatForInkCli('❌ No text content to copy');
+                }
+                // Copy to clipboard
+                const success = await writeToClipboard(textContent);
+                if (success) {
+                    const preview = textContent.length > 50
+                        ? textContent.substring(0, 50) + '...'
+                        : textContent;
+                    return formatForInkCli(`📋 Copied to clipboard (${textContent.length} chars)\n${preview.replace(/\n/g, ' ')}`);
+                }
+                else {
+                    return formatForInkCli('❌ Failed to copy to clipboard');
+                }
+            }
+            catch (error) {
+                const errorMsg = `Failed to copy: ${error instanceof Error ? error.message : String(error)}`;
+                agent.logger.error(errorMsg);
+                return formatForInkCli(`❌ ${errorMsg}`);
+            }
+        },
+    },
+    {
+        name: 'shortcuts',
+        description: 'Show keyboard shortcuts',
+        usage: '/shortcuts',
+        category: 'General',
+        aliases: ['keys', 'hotkeys'],
+        handler: async (_args, _agent, _ctx) => {
+            const styledData = {
+                categories: [
+                    {
+                        name: 'Global',
+                        shortcuts: [
+                            { keys: 'Ctrl+C', description: 'Clear input, then exit (press twice)' },
+                            { keys: 'Escape', description: 'Cancel processing / close overlay' },
+                        ],
+                    },
+                    {
+                        name: 'Input',
+                        shortcuts: [
+                            { keys: 'Enter', description: 'Submit message' },
+                            { keys: 'Shift+Enter', description: 'New line (multi-line input)' },
+                            { keys: 'Up/Down', description: 'Navigate input history' },
+                            { keys: 'Ctrl+R', description: 'Search history (enter search mode)' },
+                            { keys: 'Tab', description: 'Autocomplete command' },
+                            { keys: 'Ctrl+U', description: 'Clear input line' },
+                            { keys: 'Ctrl+W', description: 'Delete word before cursor' },
+                            { keys: 'Ctrl+A', description: 'Move cursor to start' },
+                            { keys: 'Ctrl+E', description: 'Move cursor to end' },
+                        ],
+                    },
+                    {
+                        name: 'History Search (after Ctrl+R)',
+                        shortcuts: [
+                            { keys: 'Ctrl+R', description: 'Next older match' },
+                            { keys: 'Ctrl+E', description: 'Next newer match' },
+                            { keys: 'Enter', description: 'Accept and exit search' },
+                            { keys: 'Escape', description: 'Cancel search' },
+                        ],
+                    },
+                    {
+                        name: 'Autocomplete & Selectors',
+                        shortcuts: [
+                            { keys: 'Up/Down', description: 'Navigate options' },
+                            { keys: 'Enter', description: 'Select / execute' },
+                            { keys: 'Tab', description: 'Load command into input' },
+                            { keys: 'Escape', description: 'Close overlay' },
+                        ],
+                    },
+                    {
+                        name: 'Tool Approval',
+                        shortcuts: [
+                            { keys: 'y', description: 'Allow once' },
+                            { keys: 'a', description: 'Allow for session' },
+                            { keys: 'n', description: 'Deny' },
+                            { keys: 'Escape', description: 'Cancel' },
+                        ],
+                    },
+                ],
+            };
+            // Build fallback text
+            const fallbackLines = ['Keyboard Shortcuts:'];
+            for (const category of styledData.categories) {
+                fallbackLines.push(`\n${category.name}:`);
+                for (const shortcut of category.shortcuts) {
+                    fallbackLines.push(`  ${shortcut.keys.padEnd(14)} ${shortcut.description}`);
+                }
+            }
+            return CommandOutputHelper.styled('shortcuts', styledData, fallbackLines.join('\n'));
+        },
+    },
 ];

package/dist/cli/commands/interactive-commands/mcp/index.d.ts

@@ -1,7 +1,13 @@
 /**
- * MCP Commands Index
+ * MCP Commands Module
  *
- * Exports MCP command definitions for integration with the CLI system.
+ * In interactive CLI, /mcp always shows the interactive MCP server list overlay.
+ * This command definition exists for autocomplete and help display.
  */
-export { mcpCommands } from './mcp-commands.js';
+import type { CommandDefinition } from '../command-parser.js';
+/**
+ * MCP management command definition
+ * Always shows the interactive MCP server list overlay (handled by ALWAYS_OVERLAY)
+ */
+export declare const mcpCommands: CommandDefinition;
 //# sourceMappingURL=index.d.ts.map

package/dist/cli/commands/interactive-commands/mcp/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/cli/commands/interactive-commands/mcp/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/cli/commands/interactive-commands/mcp/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,KAAK,EAAE,iBAAiB,EAAwC,MAAM,sBAAsB,CAAC;AAEpG;;;GAGG;AACH,eAAO,MAAM,WAAW,EAAE,iBAczB,CAAC"}

package/dist/cli/commands/interactive-commands/mcp/index.js

@@ -1,6 +1,21 @@
 /**
- * MCP Commands Index
+ * MCP Commands Module
  *
- * Exports MCP command definitions for integration with the CLI system.
+ * In interactive CLI, /mcp always shows the interactive MCP server list overlay.
+ * This command definition exists for autocomplete and help display.
  */
-export { mcpCommands } from './mcp-commands.js';
+/**
+ * MCP management command definition
+ * Always shows the interactive MCP server list overlay (handled by ALWAYS_OVERLAY)
+ */
+export const mcpCommands = {
+    name: 'mcp',
+    description: 'Manage MCP servers (interactive)',
+    usage: '/mcp',
+    category: 'MCP Management',
+    handler: async (_args, _agent, _ctx) => {
+        // This handler is never called - mcp is in ALWAYS_OVERLAY
+        // which intercepts and shows the MCP server list overlay instead
+        return true;
+    },
+};