@pellux/goodvibes-tui 0.19.96 → 0.19.99

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pellux/goodvibes-tui",
-  "version": "0.19.96",
+  "version": "0.19.99",
   "description": "Terminal-native GoodVibes product for coding, operations, automation, knowledge, channels, and daemon-backed control-plane workflows.",
   "type": "module",
   "main": "src/main.ts",
@@ -97,7 +97,7 @@
     "@anthropic-ai/vertex-sdk": "^0.16.0",
     "@ast-grep/napi": "^0.42.0",
     "@aws/bedrock-token-generator": "^1.1.0",
-    "@pellux/goodvibes-sdk": "0.33.26",
+    "@pellux/goodvibes-sdk": "0.33.27",
     "bash-language-server": "^5.6.0",
     "fuse.js": "^7.1.0",
     "graphql": "^16.13.2",

package/src/input/command-registry.ts

@@ -61,6 +61,11 @@ export interface CommandUiActions {
   submitInput?: (text: string, content?: import('@pellux/goodvibes-sdk/platform/providers').ContentPart[]) => void;
   submitSpokenInput?: (text: string, content?: import('@pellux/goodvibes-sdk/platform/providers').ContentPart[]) => void;
   stopSpokenOutput?: () => void;
+  pasteFromClipboard?: () => {
+    pasted: boolean;
+    kind: 'image' | 'text' | 'none';
+    marker?: string;
+  };
   executeCommand?: (name: string, args: string[]) => Promise<boolean>;
   cancelGeneration?: () => void;
   completeModelSelection?: (selection: {
@@ -110,7 +115,7 @@ export interface CommandShellUiOpeners {
   openPolicyPanel?: () => void;
   openHooksPanel?: () => void;
   openCommunicationPanel?: () => void;
-  openMcpPanel?: () => void;
+  openMcpWorkspace?: () => void;
   openSecurityPanel?: () => void;
   openKnowledgePanel?: () => void;
   openRemotePanel?: () => void;

package/src/input/commands/mcp-runtime.ts

@@ -1,20 +1,150 @@
-import type { CommandRegistry } from '../command-registry.ts';
-import { requireMcpApi } from './runtime-services.ts';
+import type { CommandContext, CommandRegistry } from '../command-registry.ts';
+import type { McpConfigScope, McpReloadResult, McpServerConfig } from '@pellux/goodvibes-sdk/platform/mcp';
+import { requireMcpApi, requireShellPaths } from './runtime-services.ts';
 import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
 
+const MCP_ROLES = ['general', 'docs', 'filesystem', 'git', 'database', 'browser', 'automation', 'ops', 'remote'] as const;
+const MCP_TRUST_MODES = ['constrained', 'ask-on-risk', 'allow-all', 'blocked'] as const;
+
+interface ParsedMcpAddArgs {
+  readonly scope: McpConfigScope;
+  readonly server: McpServerConfig;
+}
+
+function isMcpRole(value: string): value is NonNullable<McpServerConfig['role']> {
+  return MCP_ROLES.includes(value as NonNullable<McpServerConfig['role']>);
+}
+
+function isMcpTrustMode(value: string): value is NonNullable<McpServerConfig['trustMode']> {
+  return MCP_TRUST_MODES.includes(value as NonNullable<McpServerConfig['trustMode']>);
+}
+
+function isMcpScope(value: string): value is McpConfigScope {
+  return value === 'project' || value === 'global';
+}
+
+function validateServerName(name: string): string | null {
+  if (!name.trim()) return 'MCP server name is required.';
+  if (!/^[a-zA-Z0-9._-]+$/.test(name)) {
+    return 'MCP server names may contain letters, numbers, dot, underscore, and dash only.';
+  }
+  return null;
+}
+
+function readFlagValue(tokens: string[], index: number, flag: string): string {
+  const value = tokens[index + 1];
+  if (!value) {
+    throw new Error(`Missing value after ${flag}.`);
+  }
+  return value;
+}
+
+function parseAddServerArgs(args: string[]): ParsedMcpAddArgs {
+  const name = args[1]?.trim();
+  const command = args[2]?.trim();
+  if (!name || !command) {
+    throw new Error('Usage: /mcp add <name> <command> [args...] [--scope project|global] [--role <role>] [--trust <mode>] [--env KEY=VALUE] [--path <path>] [--host <host>]');
+  }
+  const nameError = validateServerName(name);
+  if (nameError) throw new Error(nameError);
+
+  const serverArgs: string[] = [];
+  const env: Record<string, string> = {};
+  const allowedPaths: string[] = [];
+  const allowedHosts: string[] = [];
+  let role: McpServerConfig['role'];
+  let trustMode: McpServerConfig['trustMode'];
+  let scope: McpConfigScope = 'project';
+  let passthrough = false;
+  const tokens = args.slice(3);
+
+  for (let index = 0; index < tokens.length; index += 1) {
+    const token = tokens[index]!;
+    if (passthrough) {
+      serverArgs.push(token);
+      continue;
+    }
+    if (token === '--') {
+      passthrough = true;
+      continue;
+    }
+    if (token === '--role') {
+      const value = readFlagValue(tokens, index, token);
+      if (!isMcpRole(value)) throw new Error(`Invalid MCP role "${value}". Expected one of: ${MCP_ROLES.join(', ')}`);
+      role = value;
+      index += 1;
+      continue;
+    }
+    if (token === '--scope') {
+      const value = readFlagValue(tokens, index, token);
+      if (!isMcpScope(value)) throw new Error(`Invalid MCP scope "${value}". Expected project or global.`);
+      scope = value;
+      index += 1;
+      continue;
+    }
+    if (token === '--trust') {
+      const value = readFlagValue(tokens, index, token);
+      if (!isMcpTrustMode(value)) throw new Error(`Invalid MCP trust mode "${value}". Expected one of: ${MCP_TRUST_MODES.join(', ')}`);
+      trustMode = value;
+      index += 1;
+      continue;
+    }
+    if (token === '--env') {
+      const value = readFlagValue(tokens, index, token);
+      const eq = value.indexOf('=');
+      if (eq <= 0) throw new Error('MCP env entries must use KEY=VALUE.');
+      env[value.slice(0, eq)] = value.slice(eq + 1);
+      index += 1;
+      continue;
+    }
+    if (token === '--path') {
+      allowedPaths.push(readFlagValue(tokens, index, token));
+      index += 1;
+      continue;
+    }
+    if (token === '--host') {
+      allowedHosts.push(readFlagValue(tokens, index, token));
+      index += 1;
+      continue;
+    }
+    serverArgs.push(token);
+  }
+
+  return {
+    scope,
+    server: {
+      name,
+      command,
+      ...(serverArgs.length > 0 ? { args: serverArgs } : {}),
+      ...(Object.keys(env).length > 0 ? { env } : {}),
+      ...(role ? { role } : {}),
+      ...(trustMode ? { trustMode } : {}),
+      ...(allowedPaths.length > 0 ? { allowedPaths } : {}),
+      ...(allowedHosts.length > 0 ? { allowedHosts } : {}),
+    },
+  };
+}
+
+async function reloadMcpRuntime(ctx: CommandContext): Promise<McpReloadResult> {
+  const result = await requireMcpApi(ctx).reload(requireShellPaths(ctx));
+  ctx.renderRequest();
+  return result;
+}
+
 export function registerMcpRuntimeCommands(registry: CommandRegistry): void {
   registry.register({
     name: 'mcp',
     aliases: [],
-    description: 'List connected MCP servers and their tools',
-    usage: '[review|tools [<server>]|auth-review|repair [server]]',
-    argsHint: '[review|tools [server]|auth-review|repair [server]]',
+    description: 'Manage MCP servers and their tools',
+    usage: '[add|remove|reload|config|review|tools [<server>]|auth-review|repair [server]]',
+    argsHint: '[add|remove|reload|config|review|tools [server]]',
     async handler(args, ctx) {
       const mcpApi = requireMcpApi(ctx);
       const listServerSecurity = () => mcpApi.listServerSecurity();
       const subcommand = args[0];
-      if (!subcommand && ctx.openMcpPanel) {
-        ctx.openMcpPanel();
+      if (!subcommand && ctx.openMcpWorkspace) {
+        ctx.openMcpWorkspace();
+        return;
       }
       if (subcommand === 'review') {
         const servers = listServerSecurity();
@@ -141,6 +271,102 @@ export function registerMcpRuntimeCommands(registry: CommandRegistry): void {
         }
       }
 
+      if (subcommand === 'add') {
+        let parsed: ParsedMcpAddArgs;
+        try {
+          parsed = parseAddServerArgs(args);
+        } catch (error) {
+          ctx.print(summarizeError(error));
+          return;
+        }
+        const shellPaths = requireShellPaths(ctx);
+        try {
+          const result = await mcpApi.upsertServerConfig(shellPaths, parsed.scope, parsed.server);
+          const connected = listServerSecurity().find((entry) => entry.name === parsed.server.name)?.connected ?? false;
+          ctx.print([
+            `MCP server "${parsed.server.name}" saved to ${parsed.scope} config: ${result.path}.`,
+            `Runtime reload: ${connected ? 'connected' : 'server saved; connection needs attention'} (+${result.reload.added} ~${result.reload.changed} -${result.reload.removed}, unchanged ${result.reload.unchanged}).`,
+            `Command: ${parsed.server.command}${parsed.server.args?.length ? ` ${parsed.server.args.join(' ')}` : ''}`,
+            'Next: /mcp tools',
+          ].join('\n'));
+        } catch (error) {
+          ctx.print(`MCP add failed: ${summarizeError(error)}`);
+        }
+        return;
+      }
+
+      if (subcommand === 'remove') {
+        const serverName = args[1]?.trim();
+        if (!serverName) {
+          ctx.print('Usage: /mcp remove <server> [--scope project|global]');
+          return;
+        }
+        let scope: McpConfigScope = 'project';
+        try {
+          for (let index = 2; index < args.length; index += 1) {
+            if (args[index] === '--scope') {
+              const value = readFlagValue(args, index, '--scope');
+              if (!isMcpScope(value)) {
+                ctx.print(`Invalid MCP scope "${value}". Expected project or global.`);
+                return;
+              }
+              scope = value;
+              index += 1;
+            }
+          }
+        } catch (error) {
+          ctx.print(summarizeError(error));
+          return;
+        }
+        const shellPaths = requireShellPaths(ctx);
+        try {
+          const result = await mcpApi.removeServerConfig(shellPaths, scope, serverName);
+          ctx.print(result.removed
+            ? `Removed MCP server "${serverName}" from ${scope} config ${result.path}. Reload: +${result.reload.added} ~${result.reload.changed} -${result.reload.removed}, unchanged ${result.reload.unchanged}.`
+            : `No ${scope} MCP server named "${serverName}" exists in ${result.path}.\nIf it still appears, it is coming from another config scope or external MCP config.`);
+        } catch (error) {
+          ctx.print(`MCP remove failed: ${summarizeError(error)}`);
+        }
+        return;
+      }
+
+      if (subcommand === 'reload') {
+        try {
+          const result = await reloadMcpRuntime(ctx);
+          const servers = listServerSecurity();
+          ctx.print(`Reloaded MCP runtime from config. ${servers.filter((server) => server.connected).length}/${servers.length} server(s) connected. Result: +${result.added} ~${result.changed} -${result.removed}, unchanged ${result.unchanged}.`);
+        } catch (error) {
+          ctx.print(`MCP reload failed: ${summarizeError(error)}`);
+        }
+        return;
+      }
+
+      if (subcommand === 'config') {
+        const shellPaths = requireShellPaths(ctx);
+        try {
+          const effective = mcpApi.getEffectiveConfig(shellPaths);
+          ctx.print([
+            'MCP Config',
+            '  locations:',
+            ...effective.locations.map((location) => `    ${location.scope}/${location.kind}${location.writable ? ' writable' : ' read-only'}  ${location.path}`),
+            `  effective servers: ${effective.servers.length}`,
+            ...effective.servers.map((entry) => {
+              const server = entry.server;
+              const envKeys = Object.keys(server.env ?? {});
+              return `  - ${server.name}: ${server.command}${server.args?.length ? ` ${server.args.join(' ')}` : ''}  source=${entry.source.scope}/${entry.source.kind}${envKeys.length ? ` envKeys=${envKeys.join(',')}` : ''}`;
+            }),
+            '',
+            'Add or update from inside the TUI:',
+            '  /mcp add <name> <command> [args...] [--scope project|global] [--role <role>] [--trust <mode>]',
+            'Example:',
+            '  /mcp add filesystem npx -y @modelcontextprotocol/server-filesystem . --scope project --role filesystem --trust constrained',
+          ].join('\n'));
+        } catch (error) {
+          ctx.print(`MCP config read failed: ${summarizeError(error)}`);
+        }
+        return;
+      }
+
       if (subcommand === 'quarantine') {
         const serverName = args[1];
         const action = args[2];
@@ -170,6 +396,8 @@ export function registerMcpRuntimeCommands(registry: CommandRegistry): void {
           + '  ~/.config/claude/claude_desktop_config.json  (Claude Desktop)\n'
           + '  .mcp/mcp.json                        (project-local)\n'
           + '  .goodvibes/mcp.json                  (goodvibes project)\n'
+          + '\nAdd one from inside the TUI:\n'
+          + '  /mcp add filesystem npx -y @modelcontextprotocol/server-filesystem . --scope project --role filesystem\n'
           + '\nFormat: { "servers": [{ "name": "my-server", "command": "npx", "args": ["-y", "@modelcontextprotocol/server-filesystem", "/tmp"] }] }'
         );
         return;
@@ -188,6 +416,8 @@ export function registerMcpRuntimeCommands(registry: CommandRegistry): void {
       if (connected.length > 0) {
         lines.push('');
         lines.push('Run "/mcp tools" to list all tools, or "/mcp tools <server>" for a specific server.');
+        lines.push('Run "/mcp" to open the fullscreen MCP workspace, or "/mcp add <name> <command> [args...] [--scope project|global]" to add/update without restarting.');
+        lines.push('Run "/mcp reload" after editing MCP config outside the TUI.');
         lines.push('Run "/mcp trust <server> <mode>" to change trust mode, or "/mcp role <server> <role>" to change its coherence role.');
         lines.push('Run "/mcp quarantine <server> [detail]" to block a server, or "/mcp quarantine <server> approve [operatorId]" to approve a temporary override.');
         lines.push('Use /settings → MCP to explicitly enable allow-all for a server.');

package/src/input/commands/shell-core.ts

@@ -91,6 +91,22 @@ export function registerShellCoreCommands(registry: CommandRegistry): void {
     },
   });
 
+  registry.register({
+    name: 'paste',
+    aliases: ['clip'],
+    description: 'Insert clipboard text or image into the prompt',
+    handler(_args, ctx) {
+      if (!ctx.pasteFromClipboard) {
+        ctx.print('Paste is not available in this context.');
+        return;
+      }
+      const result = ctx.pasteFromClipboard();
+      if (!result.pasted) {
+        ctx.print('Clipboard does not contain supported text or image data.');
+      }
+    },
+  });
+
   registry.register({
     name: 'help',
     aliases: ['h', '?'],
@@ -135,6 +151,7 @@ export function registerShellCoreCommands(registry: CommandRegistry): void {
           { id: '/template save', label: '/template save <name>', detail: 'Save prompt as template', category: 'Templates' },
           { id: '/template use', label: '/template use <name>', detail: 'Execute template', category: 'Templates' },
           { id: '/tools', label: '/tools', detail: 'List available tools', category: 'Tools & System' },
+          { id: '/paste', label: '/paste', detail: 'Insert clipboard text or image into the prompt', category: 'Tools & System' },
           { id: '/shortcuts', label: '/shortcuts', detail: 'View keyboard shortcuts reference', category: 'Tools & System' },
           { id: '/commands', label: '/commands', detail: 'Browse all commands in a scrollable list', category: 'Tools & System' },
           { id: '/secrets', label: '/secrets set|link|get|test|list|delete', detail: 'Manage encrypted and provider-backed secrets', category: 'Tools & System' },
@@ -154,7 +171,7 @@ export function registerShellCoreCommands(registry: CommandRegistry): void {
         });
         return;
       }
-      ctx.print('Use /help to open the help modal. Commands: /model, /provider, /config, /template, /tools, /sessions, /bookmarks, /save, /load, /undo, /redo, /retry, /clear, /reset, /compact, /export, /title, /effort, /expand, /collapse, /debug, /quit, /wq');
+      ctx.print('Use /help to open the help modal. Commands: /model, /provider, /config, /template, /tools, /paste, /sessions, /bookmarks, /save, /load, /undo, /redo, /retry, /clear, /reset, /compact, /export, /title, /effort, /expand, /collapse, /debug, /quit, /wq');
     },
   });
 

package/src/input/feed-context-factory.ts

@@ -29,6 +29,7 @@ import type { AgentDetailModal } from '../renderer/agent-detail-modal.ts';
 import type { ContextInspectorModal } from '../renderer/context-inspector.ts';
 import type { BookmarkModal } from './bookmark-modal.ts';
 import type { SettingsModal } from './settings-modal.ts';
+import type { McpWorkspace } from './mcp-workspace.ts';
 import type { SessionPickerModal } from './session-picker-modal.ts';
 import type { ProfilePickerModal } from './profile-picker-modal.ts';
 import type { OnboardingWizardController } from './onboarding/onboarding-wizard.ts';
@@ -98,9 +99,11 @@ export interface FeedContextStableRefs {
   selection: SelectionManager;
   pasteRegistry: Map<string, string>;
   imageRegistry: Map<string, { data: string; mediaType: string }>;
+  projectRoot: string;
   selectionModal: SelectionModal;
   bookmarkModal: BookmarkModal;
   settingsModal: SettingsModal;
+  mcpWorkspace: McpWorkspace;
   sessionPickerModal: SessionPickerModal;
   profilePickerModal: ProfilePickerModal;
   historySearch: HistorySearch;

package/src/input/handler-command-route.ts

@@ -4,6 +4,7 @@ import type { AutocompleteEngine } from './autocomplete.ts';
 import type { InputToken } from '@pellux/goodvibes-sdk/platform/core';
 import type { ConversationManager } from '../core/conversation';
 import type { PanelManager } from '../panels/panel-manager.ts';
+import { handleClipboardPaste, type ClipboardPasteSource } from './handler-content-actions.ts';
 
 export type CommandModeRouteState = {
   commandMode: boolean;
@@ -18,6 +19,14 @@ export type CommandModeRouteState = {
   conversationManager: ConversationManager | null;
   requestRender: () => void;
   handleEscape: () => void;
+  projectRoot: string;
+  pasteRegistry: Map<string, string>;
+  imageRegistry: Map<string, { data: string; mediaType: string }>;
+  nextPasteId: number;
+  nextImageId: number;
+  saveUndoState: () => void;
+  ensureInputCursorVisible: () => void;
+  clipboard?: ClipboardPasteSource;
 };
 
 export function handleCommandModeToken(state: CommandModeRouteState, token: InputToken): boolean {
@@ -141,6 +150,24 @@ function withPanelFocusSync(context: CommandContext, state: CommandModeRouteStat
           state.panelFocused = false;
         }
       : undefined,
+    pasteFromClipboard: () => {
+      const result = handleClipboardPaste({
+        prompt: state.prompt,
+        cursorPos: state.cursorPos,
+        pasteRegistry: state.pasteRegistry,
+        nextPasteId: state.nextPasteId,
+        imageRegistry: state.imageRegistry,
+        nextImageId: state.nextImageId,
+        saveUndoState: state.saveUndoState,
+        ensureInputCursorVisible: state.ensureInputCursorVisible,
+        requestRender: state.requestRender,
+      }, context.workspace.shellPaths?.workingDirectory ?? state.projectRoot, state.clipboard);
+      state.prompt = result.prompt;
+      state.cursorPos = result.cursorPos;
+      state.nextImageId = result.nextImageId;
+      state.nextPasteId = result.nextPasteId;
+      return result;
+    },
     executeCommand: async (name, args) => {
       const wrapped = withPanelFocusSync(context, state);
       const handled = state.commandRegistry?.get(name)

package/src/input/handler-content-actions.ts

@@ -56,6 +56,23 @@ export type PasteRegistryState = {
   nextImageId: number;
 };
 
+export type ClipboardPasteKind = 'image' | 'text' | 'none';
+
+export interface ClipboardPasteResult {
+  prompt: string;
+  cursorPos: number;
+  nextImageId: number;
+  nextPasteId: number;
+  pasted: boolean;
+  kind: ClipboardPasteKind;
+  marker?: string;
+}
+
+export interface ClipboardPasteSource {
+  pasteImageFromClipboard: typeof pasteImageFromClipboard;
+  pasteFromClipboard: typeof pasteFromClipboard;
+}
+
 export function registerPaste(
   state: PasteRegistryState,
   content: string,
@@ -436,22 +453,34 @@ export function handleClipboardPaste(
     requestRender: () => void;
   },
   projectRoot: string,
-): { prompt: string; cursorPos: number; nextImageId: number; nextPasteId: number } {
-  state.saveUndoState();
-  const img = pasteImageFromClipboard();
+  clipboard: ClipboardPasteSource = { pasteImageFromClipboard, pasteFromClipboard },
+): ClipboardPasteResult {
+  const img = clipboard.pasteImageFromClipboard();
+  let pasted = false;
+  let kind: ClipboardPasteKind = 'none';
+  let insertedMarker: string | undefined;
+
   if (img) {
+    state.saveUndoState();
     const id = `img${state.nextImageId++}`;
     const sizeKB = Math.round(img.data.length * 3 / 4 / 1024);
     state.imageRegistry.set(id, img);
     const marker = `[IMAGE: ${id}, clipboard, ${sizeKB}KB]`;
     state.prompt = state.prompt.slice(0, state.cursorPos) + marker + state.prompt.slice(state.cursorPos);
     state.cursorPos += marker.length;
+    pasted = true;
+    kind = 'image';
+    insertedMarker = marker;
   } else {
-    const raw = pasteFromClipboard();
+    const raw = clipboard.pasteFromClipboard();
     if (raw) {
+      state.saveUndoState();
       const { marker } = registerPaste(state, raw, projectRoot);
       state.prompt = state.prompt.slice(0, state.cursorPos) + marker + state.prompt.slice(state.cursorPos);
       state.cursorPos += marker.length;
+      pasted = true;
+      kind = marker.startsWith('[IMAGE:') ? 'image' : 'text';
+      insertedMarker = marker;
     }
   }
   state.ensureInputCursorVisible();
@@ -461,5 +490,8 @@ export function handleClipboardPaste(
     cursorPos: state.cursorPos,
     nextImageId: state.nextImageId,
     nextPasteId: state.nextPasteId,
+    pasted,
+    kind,
+    marker: insertedMarker,
   };
 }

package/src/input/handler-feed.ts

@@ -16,6 +16,7 @@ import { AgentDetailModal } from '../renderer/agent-detail-modal.ts';
 import { ContextInspectorModal } from '../renderer/context-inspector.ts';
 import { BookmarkModal } from './bookmark-modal.ts';
 import { SettingsModal } from './settings-modal.ts';
+import type { McpWorkspace } from './mcp-workspace.ts';
 import { SessionPickerModal } from './session-picker-modal.ts';
 import { ProfilePickerModal } from './profile-picker-modal.ts';
 import type { OnboardingWizardController } from './onboarding/onboarding-wizard.ts';
@@ -100,11 +101,13 @@ export interface InputFeedContext {
   contentWidth: number;
   readonly pasteRegistry: Map<string, string>;
   readonly imageRegistry: Map<string, { data: string; mediaType: string }>;
+  readonly projectRoot: string;
   readonly selection: SelectionManager;
   readonly selectionModal: SelectionModal;
   selectionCallback: ((result: SelectionResult | null) => void) | null;
   readonly bookmarkModal: BookmarkModal;
   readonly settingsModal: SettingsModal;
+  readonly mcpWorkspace: McpWorkspace;
   readonly sessionPickerModal: SessionPickerModal;
   readonly profilePickerModal: ProfilePickerModal;
   readonly historySearch: HistorySearch;
@@ -186,6 +189,7 @@ export function feedInputTokens(context: InputFeedContext, tokens: readonly Inpu
       },
       bookmarkModal: context.bookmarkModal,
       settingsModal: context.settingsModal,
+      mcpWorkspace: context.mcpWorkspace,
       sessionPickerModal: context.sessionPickerModal,
       profilePickerModal: context.profilePickerModal,
       onboardingWizard: context.onboardingWizard,
@@ -354,12 +358,21 @@ export function feedInputTokens(context: InputFeedContext, tokens: readonly Inpu
         conversationManager: context.conversationManager,
         requestRender: context.requestRender,
         handleEscape: context.handleEscape,
+        projectRoot: context.projectRoot,
+        pasteRegistry: context.pasteRegistry,
+        imageRegistry: context.imageRegistry,
+        nextPasteId: context.nextPasteId,
+        nextImageId: context.nextImageId,
+        saveUndoState: context.saveUndoState,
+        ensureInputCursorVisible: () => context.ensureInputCursorVisible(),
       };
       if (handleCommandModeToken(commandState, token)) {
         context.commandMode = commandState.commandMode;
         context.prompt = commandState.prompt;
         context.cursorPos = commandState.cursorPos;
         context.panelFocused = commandState.panelFocused;
+        context.nextPasteId = commandState.nextPasteId;
+        context.nextImageId = commandState.nextImageId;
         continue;
       }
 

package/src/input/handler-interactions.ts

@@ -238,6 +238,7 @@ export function handleEscapeForHandler(handler: InputHandler): void {
       agentDetailModal: handler.agentDetailModal,
       liveTailModal: handler.liveTailModal,
       settingsModal: handler.settingsModal,
+      mcpWorkspace: handler.mcpWorkspace,
       sessionPickerModal: handler.sessionPickerModal,
       profilePickerModal: handler.profilePickerModal,
       contextInspectorModal: handler.contextInspectorModal,

package/src/input/handler-modal-stack.ts

@@ -45,6 +45,7 @@ export type EscapeState = ModalStackState & {
     editingMode: boolean;
     cancelEdit: () => void;
   };
+  mcpWorkspace?: ModalStackState['mcpWorkspace'];
   selectionModal: ModalStackState['selectionModal'];
   autocompleteReset: () => void;
   autocompleteUpdate?: (query: string) => void;
@@ -122,6 +123,7 @@ export function handleEscape(state: EscapeState): {
       closeAgentDetail: () => state.agentDetailModal.close(),
       closeLiveTail: () => state.liveTailModal.close(),
       closeSettings: () => state.settingsModal.close(),
+      closeMcpWorkspace: () => state.mcpWorkspace?.close(),
       closeSessionPicker: () => state.sessionPickerModal.close(),
       closeProfilePicker: () => state.profilePickerModal.close(),
       closeContextInspector: () => state.contextInspectorModal.close(),
@@ -161,6 +163,7 @@ export function handleEscape(state: EscapeState): {
       openBookmark: () => state.bookmarkModal.open(),
       openProcess: () => state.processModal.open(),
       openContextInspector: () => state.contextInspectorModal.open(),
+      openMcpWorkspace: () => state.mcpWorkspace?.reopen(),
       openOnboarding: () => state.onboardingWizard?.reopen(),
       openCommandMode: () => {
         commandMode = true;

package/src/input/handler-modal-token-routes.ts

@@ -7,6 +7,7 @@ import type { SessionPickerModal } from './session-picker-modal.ts';
 import type { ProfilePickerModal } from './profile-picker-modal.ts';
 import type { HistorySearch } from './input-history.ts';
 import type { ModelPickerModal } from './model-picker.ts';
+import { handleMcpWorkspaceToken, type McpWorkspace } from './mcp-workspace.ts';
 import type { CommandContext } from './command-registry.ts';
 import type { LiveTailModal } from '../renderer/live-tail-modal.ts';
 import type { ProcessModal } from '../renderer/process-modal.ts';
@@ -43,6 +44,7 @@ export type ModalTokenRouteState = {
   setSelectionCallback?: (callback: ((result: SelectionResult | null) => void) | null) => void;
   bookmarkModal: BookmarkModal;
   settingsModal: SettingsModal;
+  mcpWorkspace: McpWorkspace;
   sessionPickerModal: SessionPickerModal;
   profilePickerModal: ProfilePickerModal;
   onboardingWizard: OnboardingWizardController;
@@ -146,6 +148,15 @@ export function handleModalTokenRoutes(state: ModalTokenRouteState, token: Input
     return withState(state, true);
   }
 
+  if (handleMcpWorkspaceToken(
+    state.mcpWorkspace,
+    token,
+    state.handleEscape,
+    state.requestRender,
+  )) {
+    return withState(state, true);
+  }
+
   if (handleSessionPickerToken({
     sessionPickerModal: state.sessionPickerModal,
     commandContext: state.commandContext,

package/src/input/handler-ui-state.ts

@@ -58,6 +58,7 @@ export type ActiveModalState = {
   agentDetailModal: { active: boolean; close: () => void };
   liveTailModal: { active: boolean; close: () => void };
   settingsModal: { active: boolean; close: () => void };
+  mcpWorkspace?: { active: boolean; close: () => void; reopen: () => void };
   sessionPickerModal: { active: boolean; close: () => void };
   profilePickerModal: { active: boolean; close: () => void };
   contextInspectorModal: { active: boolean; close: () => void };
@@ -77,6 +78,7 @@ export function getActiveModalName(state: ActiveModalState): string | null {
   if (state.agentDetailModal.active) return 'agentDetail';
   if (state.liveTailModal.active) return 'liveTail';
   if (state.settingsModal.active) return 'settings';
+  if (state.mcpWorkspace?.active) return 'mcpWorkspace';
   if (state.sessionPickerModal.active) return 'sessionPicker';
   if (state.profilePickerModal.active) return 'profilePicker';
   if (state.contextInspectorModal.active) return 'contextInspector';
@@ -97,6 +99,7 @@ export type ModalCloseOps = {
   closeAgentDetail: () => void;
   closeLiveTail: () => void;
   closeSettings: () => void;
+  closeMcpWorkspace: () => void;
   closeSessionPicker: () => void;
   closeProfilePicker: () => void;
   closeContextInspector: () => void;
@@ -129,6 +132,9 @@ export function closeModalByName(name: string, ops: ModalCloseOps): void {
     case 'settings':
       ops.closeSettings();
       break;
+    case 'mcpWorkspace':
+      ops.closeMcpWorkspace();
+      break;
     case 'sessionPicker':
       ops.closeSessionPicker();
       break;
@@ -168,6 +174,7 @@ export type ModalOpenOps = {
   openBookmark: () => void;
   openProcess: () => void;
   openContextInspector: () => void;
+  openMcpWorkspace?: () => void;
   openOnboarding?: () => void;
   openCommandMode: () => void;
 };
@@ -189,6 +196,9 @@ export function reopenModalByName(name: string, ops: ModalOpenOps): void {
     case 'contextInspector':
       ops.openContextInspector();
       break;
+    case 'mcpWorkspace':
+      ops.openMcpWorkspace?.();
+      break;
     case 'onboarding':
       ops.openOnboarding?.();
       break;