@pellux/goodvibes-tui 0.19.98 → 0.20.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pellux/goodvibes-tui",
-  "version": "0.19.98",
+  "version": "0.20.0",
   "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.30",
     "bash-language-server": "^5.6.0",
     "fuse.js": "^7.1.0",
     "graphql": "^16.13.2",

package/src/input/command-registry.ts

@@ -115,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/local-setup-review.ts

@@ -155,10 +155,13 @@ export function renderSetupSandboxReview(ctx: CommandContext, snapshot: SetupRev
   ];
   if (backend === 'local') {
     lines.push('    /sandbox qemu bootstrap .goodvibes/tui/sandbox 20');
+    lines.push('    .goodvibes/tui/sandbox/create-image.sh .goodvibes/tui/sandbox/goodvibes-sandbox.qcow2 20G');
+    lines.push('    GV_SANDBOX_SYNC_WORKSPACE=0 GV_SANDBOX_WRAPPER_MODE=launch-qemu-ssh .goodvibes/tui/sandbox/qemu-wrapper.sh bash -s < .goodvibes/tui/sandbox/guest-bootstrap.sh');
     lines.push('    /sandbox doctor');
   } else if (!image || !wrapper) {
     lines.push('    /sandbox qemu setup .goodvibes/tui/sandbox');
-    lines.push('    /sandbox qemu create-image .goodvibes/tui/sandbox/images/goodvibes-sandbox.qcow2 20');
+    lines.push('    .goodvibes/tui/sandbox/create-image.sh .goodvibes/tui/sandbox/goodvibes-sandbox.qcow2 20G');
+    lines.push('    GV_SANDBOX_SYNC_WORKSPACE=0 GV_SANDBOX_WRAPPER_MODE=launch-qemu-ssh .goodvibes/tui/sandbox/qemu-wrapper.sh bash -s < .goodvibes/tui/sandbox/guest-bootstrap.sh');
     lines.push('    /sandbox doctor');
   } else {
     lines.push('    /sandbox guest-test eval-js');

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/platform-sandbox-qemu.ts

@@ -4,7 +4,6 @@ import type { CommandContext } from '../command-registry.ts';
 import {
   applySandboxQemuSetupManifest,
   bootstrapSandboxQemuSetupBundle,
-  createSandboxQemuImage,
   inspectSandboxQemuSetupManifest,
   loadSandboxQemuSetupManifest,
   scaffoldSandboxQemuSetupBundle,
@@ -27,29 +26,25 @@ export async function handleSandboxQemuCommand(args: string[], ctx: CommandConte
       return true;
     }
     const bundle = scaffoldSandboxQemuSetupBundle(ctx.platform.configManager, shellPaths.workingDirectory, dirArg, { surfaceRoot: 'tui' });
-    ctx.platform.configManager.setDynamic('sandbox.vmBackend', 'qemu');
-    ctx.platform.configManager.setDynamic('sandbox.qemuExecWrapper', bundle.wrapperPath);
-    ctx.platform.configManager.setDynamic('sandbox.qemuImagePath', bundle.imagePath);
-    if (!`${ctx.platform.configManager.get('sandbox.qemuGuestHost') ?? ''}`.trim()) {
-      ctx.platform.configManager.setDynamic('sandbox.qemuGuestHost', '127.0.0.1');
-    }
-    if (!`${ctx.platform.configManager.get('sandbox.qemuGuestUser') ?? ''}`.trim()) {
-      ctx.platform.configManager.setDynamic('sandbox.qemuGuestUser', 'goodvibes');
-    }
-    if (!`${ctx.platform.configManager.get('sandbox.qemuWorkspacePath') ?? ''}`.trim()) {
-      ctx.platform.configManager.setDynamic('sandbox.qemuWorkspacePath', '/workspace');
-    }
+    const manifest = loadSandboxQemuSetupManifest(shellPaths.workingDirectory, bundle.manifestPath);
+    applySandboxQemuSetupManifest(ctx.platform.configManager, manifest);
+    ctx.platform.configManager.setDynamic('sandbox.replIsolation', 'shared-vm');
+    ctx.platform.configManager.setDynamic('sandbox.mcpIsolation', 'shared-vm');
     ctx.print([
       `Initialized QEMU sandbox setup bundle in ${bundle.directory}`,
       `  wrapper: ${bundle.wrapperPath}`,
       `  image path: ${bundle.imagePath}`,
       `  image create script: ${bundle.imageCreateScriptPath}`,
       `  guest bootstrap: ${bundle.guestBootstrapScriptPath}`,
+      `  seed directory: ${bundle.seedDirectory}`,
+      `  seed ISO: ${bundle.seedIsoPath}`,
+      `  ssh key: ${bundle.sshKeyPath}`,
       `  projection policy: ${bundle.projectionPolicyPath}`,
       `  ssh config: ${bundle.sshConfigPath}`,
       `  manifest: ${bundle.manifestPath}`,
-      '  applied: backend=qemu, wrapper path, image path, and default guest settings',
-      `  next: /sandbox qemu create-image ${bundle.imagePath} 20`,
+      '  applied: backend=qemu, qemu binary, wrapper path, image path, launch-per-command guest settings, shared VM isolation',
+      `  next: ${bundle.imageCreateScriptPath} ${bundle.imagePath} 20G`,
+      `  then provision runtimes: GV_SANDBOX_SYNC_WORKSPACE=0 GV_SANDBOX_WRAPPER_MODE=launch-qemu-ssh ${bundle.wrapperPath} bash -s < ${bundle.guestBootstrapScriptPath}`,
     ].join('\n'));
     return true;
   }
@@ -67,33 +62,20 @@ export async function handleSandboxQemuCommand(args: string[], ctx: CommandConte
         `  wrapper: ${bundle.wrapperPath}`,
         `  image path: ${bundle.imagePath}`,
         `  guest bootstrap: ${bundle.guestBootstrapScriptPath}`,
+        `  seed ISO: ${bundle.seedIsoPath}`,
+        `  ssh key: ${bundle.sshKeyPath}`,
         `  projection policy: ${bundle.projectionPolicyPath}`,
         `  manifest: ${bundle.manifestPath}`,
-        '  applied: backend=qemu, wrapper path, image path, and guest settings',
-        '  next: boot the image, run the guest bootstrap script, then /sandbox guest-test eval-js',
+        '  applied: backend=qemu, qemu binary, wrapper path, image path, launch-per-command guest settings, shared VM isolation',
+        `  next: ${bundle.imageCreateScriptPath} ${bundle.imagePath} ${sizeGb}G`,
+        `  then provision runtimes: GV_SANDBOX_SYNC_WORKSPACE=0 GV_SANDBOX_WRAPPER_MODE=launch-qemu-ssh ${bundle.wrapperPath} bash -s < ${bundle.guestBootstrapScriptPath}`,
+        '  then: /sandbox guest-test eval-py',
       ].join('\n'));
     } catch (error) {
       ctx.print(summarizeError(error));
     }
     return true;
   }
-  if (sub === 'create-image') {
-    const imagePath = args[2];
-    const sizeGb = Number.parseInt(args[3] ?? '20', 10);
-    if (!imagePath || !Number.isInteger(sizeGb) || sizeGb < 1) {
-      ctx.print('Usage: /sandbox qemu create-image <path> [size-gb]');
-      return true;
-    }
-    try {
-      const created = createSandboxQemuImage(shellPaths.workingDirectory, imagePath, sizeGb);
-      ctx.platform.configManager.setDynamic('sandbox.qemuImagePath', created.path);
-      ctx.platform.configManager.setDynamic('sandbox.vmBackend', 'qemu');
-      ctx.print(`Created QEMU image ${created.path} (${created.sizeGb}G).`);
-    } catch (error) {
-      ctx.print(summarizeError(error));
-    }
-    return true;
-  }
   if (sub === 'recover') {
     const sessionId = args[2];
     if (!sessionId) {
@@ -132,6 +114,6 @@ export async function handleSandboxQemuCommand(args: string[], ctx: CommandConte
     ctx.print(`Applied QEMU sandbox setup from ${shellPaths.resolveWorkspacePath(pathArg)}.`);
     return true;
   }
-  ctx.print('Usage: /sandbox qemu <setup <directory>|bootstrap <directory> [size-gb]|create-image <path> [size-gb]|recover <session-id>|inspect-setup <setup-manifest.json>|apply-setup <setup-manifest.json>>');
+  ctx.print('Usage: /sandbox qemu <setup <directory>|bootstrap <directory> [size-gb]|recover <session-id>|inspect-setup <setup-manifest.json>|apply-setup <setup-manifest.json>>');
   return true;
 }

package/src/input/commands/platform-sandbox-runtime.ts

@@ -61,6 +61,7 @@ function applySandboxPreset(
   configManager.setDynamic('sandbox.qemuGuestUser' as never, preset.config.qemuGuestUser);
   configManager.setDynamic('sandbox.qemuWorkspacePath' as never, preset.config.qemuWorkspacePath);
   configManager.setDynamic('sandbox.qemuSessionMode' as never, preset.config.qemuSessionMode);
+  configManager.setDynamic('sandbox.replJavaScriptCommand' as never, preset.config.replJavaScriptCommand);
   return true;
 }
 
@@ -83,6 +84,7 @@ function renderSandboxPresetDetail(presetId: string): string | null {
     `  qemu guest user: ${preset.config.qemuGuestUser || '(not configured)'}`,
     `  qemu workspace: ${preset.config.qemuWorkspacePath || '(not configured)'}`,
     `  qemu session mode: ${preset.config.qemuSessionMode}`,
+    `  repl JavaScript command: ${preset.config.replJavaScriptCommand || 'bun'}`,
     ...preset.notes.map((note) => `  note: ${note}`),
   ].join('\n');
 }
@@ -91,7 +93,7 @@ export function registerPlatformSandboxRuntimeCommands(registry: CommandRegistry
   registry.register({
     name: 'sandbox',
     description: 'Review and configure VM isolation policy for MCP and evaluation runtimes',
-    usage: '[open|review|recommend|profiles|presets|preset <id>|apply-preset <id>|probe|doctor|wrapper-test <profile>|guest-test <profile>|init-qemu <dir>|qemu <setup|bootstrap|create-image|recover|inspect-setup|apply-setup> ...|session ...|bundle ...|guest-bundle <export|inspect> <path>|scaffold-qemu-wrapper <path>|set-mcp <mode>|set-repl <mode>|set-windows <mode>|set-backend <mode>|set-qemu-binary <path>|set-qemu-image <path>|set-qemu-wrapper <path>|set-qemu-guest-host <host>|set-qemu-guest-port <port>|set-qemu-guest-user <user>|set-qemu-workspace <path>|set-qemu-session-mode <attach|launch-per-command>]',
+    usage: '[open|review|recommend|profiles|presets|preset <id>|apply-preset <id>|probe|doctor|wrapper-test <profile>|guest-test <profile>|init-qemu <dir>|qemu <setup|bootstrap|recover|inspect-setup|apply-setup> ...|session ...|bundle ...|guest-bundle <export|inspect> <path>|scaffold-qemu-wrapper <path>|set-mcp <mode>|set-repl <mode>|set-windows <mode>|set-backend <mode>|set-qemu-binary <path>|set-qemu-image <path>|set-qemu-wrapper <path>|set-qemu-guest-host <host>|set-qemu-guest-port <port>|set-qemu-guest-user <user>|set-qemu-workspace <path>|set-qemu-session-mode <attach|launch-per-command>]',
     async handler(args, ctx) {
       const shellPaths = requireShellPaths(ctx);
       const sub = args[0] ?? 'open';
@@ -400,7 +402,7 @@ export function registerPlatformSandboxRuntimeCommands(registry: CommandRegistry
         ctx.print([`Scaffolded QEMU wrapper to ${targetPath}`, '  bridge test mode: GV_SANDBOX_WRAPPER_MODE=host-exec', '  next: /sandbox set-qemu-wrapper ' + targetPath].join('\n'));
         return;
       }
-      ctx.print('Usage: /sandbox [open|review|recommend|profiles|presets|preset <id>|apply-preset <id>|probe|doctor|wrapper-test <profile>|guest-test <profile>|init-qemu <dir>|qemu <setup|bootstrap|create-image|recover|inspect-setup|apply-setup> ...|session ...|bundle export <path>|bundle inspect <path>|guest-bundle <export|inspect> <path>|scaffold-qemu-wrapper <path>|set-mcp <mode>|set-repl <mode>|set-windows <mode>|set-backend <mode>|set-qemu-binary <path>|set-qemu-image <path>|set-qemu-wrapper <path>|set-qemu-guest-host <host>|set-qemu-guest-port <port>|set-qemu-guest-user <user>|set-qemu-workspace <path>|set-qemu-session-mode <attach|launch-per-command>]');
+      ctx.print('Usage: /sandbox [open|review|recommend|profiles|presets|preset <id>|apply-preset <id>|probe|doctor|wrapper-test <profile>|guest-test <profile>|init-qemu <dir>|qemu <setup|bootstrap|recover|inspect-setup|apply-setup> ...|session ...|bundle export <path>|bundle inspect <path>|guest-bundle <export|inspect> <path>|scaffold-qemu-wrapper <path>|set-mcp <mode>|set-repl <mode>|set-windows <mode>|set-backend <mode>|set-qemu-binary <path>|set-qemu-image <path>|set-qemu-wrapper <path>|set-qemu-guest-host <host>|set-qemu-guest-port <port>|set-qemu-guest-user <user>|set-qemu-workspace <path>|set-qemu-session-mode <attach|launch-per-command>]');
     },
   });
 }

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';
@@ -102,6 +103,7 @@ export interface FeedContextStableRefs {
   selectionModal: SelectionModal;
   bookmarkModal: BookmarkModal;
   settingsModal: SettingsModal;
+  mcpWorkspace: McpWorkspace;
   sessionPickerModal: SessionPickerModal;
   profilePickerModal: ProfilePickerModal;
   historySearch: HistorySearch;

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';
@@ -106,6 +107,7 @@ export interface InputFeedContext {
   selectionCallback: ((result: SelectionResult | null) => void) | null;
   readonly bookmarkModal: BookmarkModal;
   readonly settingsModal: SettingsModal;
+  readonly mcpWorkspace: McpWorkspace;
   readonly sessionPickerModal: SessionPickerModal;
   readonly profilePickerModal: ProfilePickerModal;
   readonly historySearch: HistorySearch;
@@ -187,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,

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;

package/src/input/handler.ts

@@ -25,6 +25,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 { McpWorkspace } from './mcp-workspace.ts';
 import { SessionPickerModal } from './session-picker-modal.ts';
 import { ProfilePickerModal } from './profile-picker-modal.ts';
 import { OnboardingWizardController, type OnboardingWizardAction, type OnboardingWizardMode } from './onboarding/onboarding-wizard.ts';
@@ -157,6 +158,7 @@ export class InputHandler {
   public bookmarkModal: BookmarkModal;
   public blockActionsMenu = new BlockActionsMenu();
   public settingsModal = new SettingsModal();
+  public mcpWorkspace = new McpWorkspace();
   public onboardingWizard = new OnboardingWizardController();
   public onboardingModelPickerCancelSnapshot: OnboardingWizardSnapshot | null = null;
   public onboardingHydrationSerial = 0;
@@ -275,6 +277,7 @@ export class InputHandler {
         selectionModal: this.selectionModal,
         bookmarkModal: this.bookmarkModal,
         settingsModal: this.settingsModal,
+        mcpWorkspace: this.mcpWorkspace,
         sessionPickerModal: this.sessionPickerModal,
         profilePickerModal: this.profilePickerModal,
         historySearch: this.historySearch,
@@ -411,6 +414,13 @@ export class InputHandler {
   public restoreOnboardingModelPickerCancelState(): void { restoreOnboardingModelPickerCancelStateForHandler(this); }
   public openModelPickerWithTarget(target: ModelPickerTarget, source: 'settings' | 'onboarding' = 'settings'): boolean { return openModelPickerWithTargetForHandler(this, target, source); }
   public openProviderModelPickerWithTarget(target: ModelPickerTarget, source: 'settings' | 'onboarding' = 'settings'): boolean { return openProviderModelPickerWithTargetForHandler(this, target, source); }
+  public openMcpWorkspace(context: CommandContext): void {
+    this.panelFocused = false;
+    this.indicatorFocused = false;
+    this.modalOpened('mcpWorkspace');
+    this.mcpWorkspace.open(context);
+    this.requestRender();
+  }
   public handleModelPickerCommit(): boolean { return handleModelPickerCommitForHandler(this); }
   public async handleOnboardingAction(action: OnboardingWizardAction): Promise<void> { await handleOnboardingActionForHandler(this, action); }
   public async refreshOnboardingHydration(options: { readonly preserveValues?: boolean; readonly targetStepId?: string } = {}): Promise<void> { await refreshOnboardingHydrationForHandler(this, options); }