@pellux/goodvibes-agent 0.1.116 → 1.0.0

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

@@ -9,6 +9,10 @@ import { BUILTIN_SECRET_PROVIDER_SOURCES, describeSecretRef, isSecretRefInput, r
 import { requireBookmarkManager, requireProviderApi, requireSecretsManager } from './runtime-services.ts';
 import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
 import { requireYesFlag, stripYesFlag } from './confirmation.ts';
+import {
+  formatAgentMediaGenerationResult,
+  generateAgentMedia,
+} from '../../agent/media-generation.ts';
 
 function isGoodVibesSecretRefInput(value: string): boolean {
   const normalized = value.trim();
@@ -23,7 +27,7 @@ function isMalformedGoodVibesSecretRefInput(value: string): boolean {
 function toggleBlocks(typeFilter: string, collapsed: boolean, ctx: CommandContext): void {
   const VALID_TYPES = ['all', 'thinking', 'tool', 'code'] as const;
   if (!VALID_TYPES.includes(typeFilter as typeof VALID_TYPES[number])) {
-    ctx.print(`Unknown type: ${typeFilter}\nValid types: ${VALID_TYPES.join(', ')}`);
+    ctx.print(`Unknown type ${typeFilter}\nValid types ${VALID_TYPES.join(', ')}`);
     return;
   }
   const blockRegistry = ctx.session.conversationManager.getBlockRegistry();
@@ -49,6 +53,60 @@ function toggleBlocks(typeFilter: string, collapsed: boolean, ctx: CommandContex
   ctx.renderRequest();
 }
 
+interface MediaGenerateArgs {
+  readonly prompt: string;
+  readonly providerId?: string;
+  readonly modelId?: string;
+  readonly outputMimeType?: string;
+  readonly yes: boolean;
+  readonly errors: readonly string[];
+}
+
+function readFlagValue(args: readonly string[], index: number, flag: string, errors: string[]): string | null {
+  const value = args[index + 1];
+  if (!value || value.startsWith('--')) {
+    errors.push(`${flag} requires a value.`);
+    return null;
+  }
+  return value;
+}
+
+function parseMediaGenerateArgs(args: readonly string[]): MediaGenerateArgs {
+  const parsed = stripYesFlag([...args]);
+  const errors: string[] = [];
+  const promptParts: string[] = [];
+  let providerId: string | undefined;
+  let modelId: string | undefined;
+  let outputMimeType: string | undefined;
+  for (let index = 0; index < parsed.rest.length; index += 1) {
+    const arg = parsed.rest[index];
+    if (arg === '--provider') {
+      providerId = readFlagValue(parsed.rest, index, arg, errors) ?? providerId;
+      index += 1;
+    } else if (arg === '--model') {
+      modelId = readFlagValue(parsed.rest, index, arg, errors) ?? modelId;
+      index += 1;
+    } else if (arg === '--mime') {
+      outputMimeType = readFlagValue(parsed.rest, index, arg, errors) ?? outputMimeType;
+      index += 1;
+    } else if (arg?.startsWith('--')) {
+      errors.push(`Unknown media generation flag ${arg}`);
+    } else if (arg) {
+      promptParts.push(arg);
+    }
+  }
+  const prompt = promptParts.join(' ').trim();
+  if (!prompt) errors.push('Media generation prompt is required.');
+  return {
+    prompt,
+    ...(providerId ? { providerId } : {}),
+    ...(modelId ? { modelId } : {}),
+    ...(outputMimeType ? { outputMimeType } : {}),
+    yes: parsed.yes,
+    errors,
+  };
+}
+
 export function registerLocalRuntimeCommands(registry: CommandRegistry): void {
   registry.register({ name: 'expand', description: 'Expand blocks by type', usage: '[all|thinking|tool|code]', argsHint: '[all|thinking|tool|code]', handler(args, ctx) { toggleBlocks(args[0] || 'all', false, ctx); } });
   registry.register({ name: 'collapse', description: 'Collapse blocks by type', usage: '[all|thinking|tool|code]', argsHint: '[all|thinking|tool|code]', handler(args, ctx) { toggleBlocks(args[0] || 'all', true, ctx); } });
@@ -130,9 +188,12 @@ export function registerLocalRuntimeCommands(registry: CommandRegistry): void {
         }
         try {
           const resolved = await resolveSecretRef(refText, { resolveLocalSecret: (key) => mgr.get(key) });
-          ctx.print(`[secrets] ${describeSecretRef(refText)}: ${resolved.value ? 'resolved <redacted>' : 'missing'}`);
+          ctx.print([
+            `[secrets] ${describeSecretRef(refText)}`,
+            `  status ${resolved.value ? 'resolved <redacted>' : 'missing'}`,
+          ].join('\n'));
         } catch (error) {
-          ctx.print(`[secrets] ${describeSecretRef(refText)} failed: ${summarizeError(error)}`);
+          ctx.print(`[secrets] ${describeSecretRef(refText)} failed ${summarizeError(error)}`);
         }
         return;
       }
@@ -190,7 +251,10 @@ export function registerLocalRuntimeCommands(registry: CommandRegistry): void {
           scope: flags.has('--user') ? 'user' : flags.has('--project') ? 'project' : undefined,
           medium: flags.has('--plaintext') ? 'plaintext' : flags.has('--secure') ? 'secure' : undefined,
         });
-        ctx.print(`[secrets] Deleted: ${key}`);
+        ctx.print([
+          '[secrets] Deleted',
+          `  key ${key}`,
+        ].join('\n'));
         return;
       }
       ctx.print('[secrets] Usage: /secrets set <KEY> <value> [--user|--project] [--secure|--plaintext] --yes | link <KEY> <secret-ref> [--user|--project] [--secure|--plaintext] --yes | get <KEY> | test <secret-ref> | providers | list | delete <KEY> [--user|--project] [--secure|--plaintext] --yes');
@@ -212,36 +276,42 @@ export function registerLocalRuntimeCommands(registry: CommandRegistry): void {
       const promptText = args.slice(1).join(' ') || `Attached image: ${rawPath.split('/').pop() ?? rawPath}`;
       const projectRoot = ctx.workspace.shellPaths?.workingDirectory ?? ctx.platform.configManager.getWorkingDirectory();
       if (!projectRoot) {
-        ctx.print('Error: working directory is unavailable.');
+        ctx.print([
+          'Error',
+          '  message working directory is unavailable.',
+        ].join('\n'));
         return;
       }
       let resolvedPath: string;
       try {
         resolvedPath = resolveAndValidatePath(rawPath, projectRoot);
       } catch (err) {
-        ctx.print(`Error: ${summarizeError(err)}`);
+        ctx.print([
+          'Error',
+          `  message ${summarizeError(err)}`,
+        ].join('\n'));
         return;
       }
       if (!existsSync(resolvedPath)) {
-        ctx.print(`File not found: ${rawPath}`);
+        ctx.print(`File not found ${rawPath}`);
         return;
       }
       const ext = resolvedPath.slice(resolvedPath.lastIndexOf('.')).toLowerCase();
       const mediaType = ({ '.png': 'image/png', '.jpg': 'image/jpeg', '.jpeg': 'image/jpeg', '.webp': 'image/webp', '.gif': 'image/gif' } as Record<string, string>)[ext];
       if (!mediaType) {
-        ctx.print(`Unsupported image format: ${ext}\nSupported: .png, .jpg, .jpeg, .webp, .gif`);
+        ctx.print(`Unsupported image format ${ext}\nSupported .png, .jpg, .jpeg, .webp, .gif`);
         return;
       }
       const stat = statSync(resolvedPath);
       if (stat.size > 20 * 1024 * 1024) {
-        ctx.print(`Image too large (${(stat.size / 1024 / 1024).toFixed(1)}MB). Maximum: 20MB`);
+        ctx.print(`Image too large (${(stat.size / 1024 / 1024).toFixed(1)}MB). Maximum 20MB`);
         return;
       }
       let data: string;
       try {
         data = (await readFile(resolvedPath)).toString('base64');
       } catch (err) {
-        ctx.print(`Failed to read image: ${summarizeError(err)}`);
+        ctx.print(`Failed to read image ${summarizeError(err)}`);
         return;
       }
       const currentModel = await requireProviderApi(ctx).getCurrentModel();
@@ -253,6 +323,53 @@ export function registerLocalRuntimeCommands(registry: CommandRegistry): void {
     },
   });
 
+  registry.register({
+    name: 'media',
+    description: 'Inspect media providers or generate media through configured providers',
+    usage: 'providers | generate [--provider <id>] [--model <id>] [--mime <mime>] <prompt> --yes',
+    argsHint: '<providers|generate>',
+    async handler(args, ctx) {
+      const subcommand = args[0]?.toLowerCase() || 'providers';
+      const registry = ctx.platform.mediaProviderRegistry;
+      if (!registry) {
+        ctx.print('[media] Media providers are not available in this runtime.');
+        return;
+      }
+      if (subcommand === 'providers' || subcommand === 'status' || subcommand === 'list') {
+        const statuses = await registry.status();
+        ctx.print([
+          '[media] Providers:',
+          ...statuses.map((provider) => `  ${provider.id}: ${provider.state}${provider.configured ? '' : ' (setup needed)'} - ${provider.capabilities.join(', ')}${provider.detail ? ` - ${provider.detail}` : ''}`),
+        ].join('\n'));
+        return;
+      }
+      if (subcommand !== 'generate') {
+        ctx.print('[media] Usage: /media providers | /media generate [--provider <id>] [--model <id>] [--mime <mime>] <prompt> --yes');
+        return;
+      }
+      const artifactStore = ctx.platform.artifactStore;
+      if (!artifactStore) {
+        ctx.print('[media] Artifact storage is not available in this runtime.');
+        return;
+      }
+      const parsed = parseMediaGenerateArgs(args.slice(1));
+      if (parsed.errors.length > 0) {
+        ctx.print(`[media] ${parsed.errors.join('\n[media] ')}`);
+        return;
+      }
+      if (!parsed.yes) {
+        requireYesFlag(ctx, `generate media for "${parsed.prompt}"`, '/media generate [--provider <id>] [--model <id>] [--mime <mime>] <prompt> --yes');
+        return;
+      }
+      try {
+        const result = await generateAgentMedia(registry, artifactStore, parsed);
+        ctx.print(formatAgentMediaGenerationResult(result));
+      } catch (error) {
+        ctx.print(`[media] Generation failed ${summarizeError(error)}`);
+      }
+    },
+  });
+
   registry.register({
     name: 'refresh-models',
     description: 'Refresh model catalog, benchmarks, and token limits',
@@ -267,15 +384,17 @@ export function registerLocalRuntimeCommands(registry: CommandRegistry): void {
         catalogOk = true;
         ctx.print(`Model catalog refreshed: ${catalog.modelCount} models from ${catalog.providerCount} providers`);
       } catch (e) {
-        ctx.print(`Catalog refresh failed: ${summarizeError(e)}`);
+        ctx.print(`Catalog refresh failed ${summarizeError(e)}`);
       }
       ctx.print('Refreshing benchmarks...');
       try {
         const benchmarkCount = await providerApi.refreshBenchmarks();
         benchmarksOk = true;
-        ctx.print(`Benchmarks refreshed${benchmarkCount > 0 ? `: ${benchmarkCount} model records available.` : '.'}`);
+        ctx.print(benchmarkCount > 0
+          ? `Benchmarks refreshed: ${benchmarkCount} model records available.`
+          : 'Benchmarks refreshed.');
       } catch (e) {
-        ctx.print(`Benchmarks refresh failed: ${summarizeError(e)}`);
+        ctx.print(`Benchmarks refresh failed ${summarizeError(e)}`);
       }
       ctx.print('Refreshing token limits...');
       try {
@@ -283,7 +402,7 @@ export function registerLocalRuntimeCommands(registry: CommandRegistry): void {
         limitsOk = true;
         ctx.print(`Token limits refreshed: ${count} models updated.`);
       } catch (e) {
-        ctx.print(`Token limits refresh failed: ${summarizeError(e)}`);
+        ctx.print(`Token limits refresh failed ${summarizeError(e)}`);
       }
       if (!catalogOk || !benchmarksOk || !limitsOk) ctx.print('Some refreshes failed — see messages above.');
     },
@@ -308,14 +427,17 @@ export function registerLocalRuntimeCommands(registry: CommandRegistry): void {
       }
       const favorites = await providerApi.getFavorites();
       if (favorites.pinned.some((entry) => entry.modelId === modelId || entry.registryKey === modelId)) {
-        ctx.print(`Model already pinned: ${modelId}`);
+        ctx.print(`Model already pinned ${modelId}`);
         return;
       }
       try {
         await providerApi.pinModel(modelId);
         ctx.print(`Pinned: ${modelId}`);
       } catch (e) {
-        ctx.print(`Error: ${summarizeError(e)}`);
+        ctx.print([
+          'Error',
+          `  message ${summarizeError(e)}`,
+        ].join('\n'));
       }
     },
   });

package/src/input/commands/local-setup-review.ts

@@ -13,7 +13,7 @@ export interface SetupReviewSnapshot {
   readonly builtinSubscriptionProviderCount: number;
   readonly activeSubscriptionCount: number;
   readonly pendingSubscriptionCount: number;
-  readonly serviceIssues: string[];
+  readonly hostIntegrationIssues: string[];
   readonly skillCount: number;
   readonly pluginCount: number;
   readonly quarantinedPluginCount: number;
@@ -33,11 +33,11 @@ export async function buildSetupReviewSnapshot(ctx: CommandContext): Promise<Set
   const serviceRegistry = requireServiceRegistry(ctx);
   const services = Object.keys(serviceRegistry.getAll()).sort((a, b) => a.localeCompare(b));
   const serviceConfigs = serviceRegistry.getAll();
-  const serviceIssues: string[] = [];
+  const hostIntegrationIssues: string[] = [];
   for (const name of services) {
     const inspection = await serviceRegistry.inspect(name);
     if (!inspection?.hasPrimaryCredential) {
-      serviceIssues.push(`${name}: missing primary credential`);
+      hostIntegrationIssues.push(`${name}: missing primary credential`);
     }
   }
 
@@ -79,13 +79,13 @@ export async function buildSetupReviewSnapshot(ctx: CommandContext): Promise<Set
       message: providerCount > 0 ? `${providerCount} model(s) available` : 'no models available',
     },
     {
-      severity: (services.length === 0 && oauthProviderCount === 0 && builtinSubscriptionProviderCount === 0) ? 'warn' : serviceIssues.length === 0 ? 'pass' : 'warn',
-      area: 'services',
+      severity: (services.length === 0 && oauthProviderCount === 0 && builtinSubscriptionProviderCount === 0) ? 'warn' : hostIntegrationIssues.length === 0 ? 'pass' : 'warn',
+      area: 'host',
       message: (services.length === 0 && oauthProviderCount === 0 && builtinSubscriptionProviderCount === 0)
-        ? 'no services configured'
-        : serviceIssues.length === 0
-          ? `${services.length} service(s), ${oauthProviderCount + builtinSubscriptionProviderCount} oauth provider(s), ${activeSubscriptionCount} active subscription override(s)`
-          : `${serviceIssues.length} service configuration issue(s)`,
+        ? 'no connected host integrations configured'
+        : hostIntegrationIssues.length === 0
+          ? `${services.length} host integration(s), ${oauthProviderCount + builtinSubscriptionProviderCount} oauth provider(s), ${activeSubscriptionCount} active subscription override(s)`
+          : `${hostIntegrationIssues.length} host integration configuration issue(s)`,
     },
     {
       severity: quarantinedPluginCount === 0 ? 'pass' : 'warn',
@@ -101,16 +101,6 @@ export async function buildSetupReviewSnapshot(ctx: CommandContext): Promise<Set
         ? `${quarantinedMcpCount} quarantined, ${elevatedMcpCount} elevated`
         : `${mcpServers.length} server(s) known`,
     },
-    {
-      severity: managedHookCount > 0 || managedHookChainCount > 0 ? 'pass' : 'warn',
-      area: 'hooks',
-      message: `${managedHookCount} managed hook(s), ${managedHookChainCount} chain(s)`,
-    },
-    {
-      severity: remoteRunnerCount > 0 ? 'pass' : 'warn',
-      area: 'remote',
-      message: remoteRunnerCount > 0 ? `${remoteRunnerCount} remote worker contract(s)` : 'no remote worker contracts registered',
-    },
   ];
 
   return {
@@ -121,7 +111,7 @@ export async function buildSetupReviewSnapshot(ctx: CommandContext): Promise<Set
     builtinSubscriptionProviderCount,
     activeSubscriptionCount,
     pendingSubscriptionCount,
-    serviceIssues,
+    hostIntegrationIssues,
     skillCount: skills.length,
     pluginCount: plugins.length,
     quarantinedPluginCount,

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

@@ -12,6 +12,11 @@ interface ParsedMcpAddArgs {
   readonly server: McpServerConfig;
 }
 
+type McpSecurityServer = ReturnType<NonNullable<NonNullable<CommandContext['clients']>['mcpApi']>['listServerSecurity']>[number];
+type McpDisplayTrustMode = NonNullable<McpServerConfig['trustMode']> | McpSecurityServer['trustMode'];
+type McpDisplayRole = NonNullable<McpServerConfig['role']> | McpSecurityServer['role'];
+type McpDisplayFreshness = McpSecurityServer['schemaFreshness'];
+
 function isMcpRole(value: string): value is NonNullable<McpServerConfig['role']> {
   return MCP_ROLES.includes(value as NonNullable<McpServerConfig['role']>);
 }
@@ -24,6 +29,21 @@ function isMcpScope(value: string): value is McpConfigScope {
   return value === 'project' || value === 'global';
 }
 
+function formatMcpTrustMode(mode: McpDisplayTrustMode): string {
+  if (mode === 'ask-on-risk') return 'ask on risky actions';
+  if (mode === 'allow-all') return 'allow all actions';
+  return mode.replace(/[_-]+/g, ' ');
+}
+
+function formatMcpFreshness(value: McpDisplayFreshness): string {
+  if (value === 'quarantined') return 'needs review';
+  return value.replace(/[_-]+/g, ' ');
+}
+
+function formatMcpRole(value: McpDisplayRole): string {
+  return value.replace(/[_-]+/g, ' ');
+}
+
 function validateServerName(name: string): string | null {
   if (!name.trim()) return 'MCP server name is required.';
   if (!/^[a-zA-Z0-9._-]+$/.test(name)) {
@@ -71,7 +91,7 @@ function parseAddServerArgs(args: string[]): ParsedMcpAddArgs {
     }
     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(', ')}`);
+      if (!isMcpRole(value)) throw new Error(`Invalid MCP role "${value}". Expected one of ${MCP_ROLES.join(', ')}.`);
       role = value;
       index += 1;
       continue;
@@ -85,7 +105,7 @@ function parseAddServerArgs(args: string[]): ParsedMcpAddArgs {
     }
     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(', ')}`);
+      if (!isMcpTrustMode(value)) throw new Error(`Invalid MCP trust mode "${value}". Expected one of ${MCP_TRUST_MODES.join(', ')}.`);
       trustMode = value;
       index += 1;
       continue;
@@ -157,7 +177,7 @@ export function registerMcpRuntimeCommands(registry: CommandRegistry): void {
           `  servers: ${servers.length}`,
           `  connected: ${servers.filter((server) => server.connected).length}`,
           `  auth or repair attention: ${authRequired.length}`,
-          ...servers.map((server) => `  ${server.name}  trust=${server.trustMode}  role=${server.role}  freshness=${server.schemaFreshness}  connected=${server.connected ? 'yes' : 'no'}`),
+          ...servers.map((server) => `  ${server.name}  trust=${formatMcpTrustMode(server.trustMode)}  role=${formatMcpRole(server.role)}  status=${formatMcpFreshness(server.schemaFreshness)}  connected=${server.connected ? 'yes' : 'no'}`),
           '  next: /mcp auth-review',
           '  next: /mcp repair <server>',
         ].join('\n'));
@@ -174,8 +194,7 @@ 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 Agent with explicit confirmation:\n'
-            + '  /mcp add filesystem npx -y @modelcontextprotocol/server-filesystem . --scope project --role filesystem --yes'
+            + '\nOpen /mcp and choose Add or update server, or use Agent Workspace -> Tools & MCP -> Add MCP server.'
           );
           return;
         }
@@ -219,7 +238,7 @@ export function registerMcpRuntimeCommands(registry: CommandRegistry): void {
           ? [
               'MCP Auth Review',
               ...needingAttention.map((server) => (
-                `  ${server.name}  connected=${server.connected ? 'yes' : 'no'}  freshness=${server.schemaFreshness}  trust=${server.trustMode}`
+                `  ${server.name}  connected ${server.connected ? 'yes' : 'no'}  status ${formatMcpFreshness(server.schemaFreshness)}  trust ${formatMcpTrustMode(server.trustMode)}`
               )),
               '  next: /auth review',
               '  next: /mcp repair <server>',
@@ -234,7 +253,7 @@ export function registerMcpRuntimeCommands(registry: CommandRegistry): void {
         const selected = serverName ? servers.find((server) => server.name === serverName) : servers.find((server) => !server.connected || server.schemaFreshness === 'quarantined');
         if (!selected) {
           ctx.print(serverName
-            ? `Unknown MCP server: ${serverName}`
+            ? `Unknown MCP server ${serverName}`
             : 'MCP Repair\n  No MCP server currently needs repair.');
           return;
         }
@@ -249,9 +268,9 @@ export function registerMcpRuntimeCommands(registry: CommandRegistry): void {
         ctx.print([
           `MCP Repair: ${selected.name}`,
           `  connected: ${selected.connected ? 'yes' : 'no'}`,
-          `  trust: ${selected.trustMode}`,
-          `  role: ${selected.role}`,
-          `  freshness: ${selected.schemaFreshness}`,
+          `  trust: ${formatMcpTrustMode(selected.trustMode)}`,
+          `  role: ${formatMcpRole(selected.role)}`,
+          `  status: ${formatMcpFreshness(selected.schemaFreshness)}`,
           ...(selected.quarantineReason ? [`  quarantine: ${selected.quarantineReason}`] : []),
           ...(selected.quarantineDetail ? [`  detail: ${selected.quarantineDetail}`] : []),
           '  next:',
@@ -265,7 +284,7 @@ export function registerMcpRuntimeCommands(registry: CommandRegistry): void {
         const mode = commandArgs[2] as 'constrained' | 'ask-on-risk' | 'allow-all' | 'blocked' | undefined;
         if (serverName && mode) {
           if (mode === 'allow-all') {
-            ctx.print(`Use /settings → MCP to explicitly enable allow-all for ${serverName}. Direct CLI escalation is blocked.`);
+            ctx.print(`Use /settings → MCP to explicitly enable allow-all for ${serverName}. Direct command escalation is blocked.`);
             ctx.openSettingsModal?.();
             return;
           }
@@ -274,7 +293,7 @@ export function registerMcpRuntimeCommands(registry: CommandRegistry): void {
             return;
           }
           mcpApi.setServerTrustMode(serverName, mode);
-          ctx.print(`Updated MCP trust mode for ${serverName} to ${mode}.`);
+          ctx.print(`Updated MCP trust mode for ${serverName} to ${formatMcpTrustMode(mode)}.`);
           return;
         }
         if (serverName || mode) {
@@ -292,7 +311,7 @@ export function registerMcpRuntimeCommands(registry: CommandRegistry): void {
             return;
           }
           mcpApi.setServerRole(serverName, role);
-          ctx.print(`Updated MCP role for ${serverName} to ${role}.`);
+          ctx.print(`Updated MCP role for ${serverName} to ${formatMcpRole(role)}.`);
           return;
         }
         if (serverName || role) {
@@ -318,13 +337,16 @@ export function registerMcpRuntimeCommands(registry: CommandRegistry): void {
           const result = await mcpApi.upsertServerConfig(shellPaths, parsedAdd.scope, parsedAdd.server);
           const connected = listServerSecurity().find((entry) => entry.name === parsedAdd.server.name)?.connected ?? false;
           ctx.print([
-            `MCP server "${parsedAdd.server.name}" saved to ${parsedAdd.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: ${parsedAdd.server.command}${parsedAdd.server.args?.length ? ` ${parsedAdd.server.args.join(' ')}` : ''}`,
-            'Next: /mcp tools',
+            `MCP server "${parsedAdd.server.name}" saved`,
+            `  scope ${parsedAdd.scope}`,
+            `  path ${result.path}`,
+            ...(parsedAdd.scope === 'global' ? ['  global config'] : []),
+            `  Runtime reload: ${connected ? 'connected' : 'server saved; connection needs attention'} (+${result.reload.added} ~${result.reload.changed} -${result.reload.removed}, unchanged ${result.reload.unchanged})`,
+            `  command ${parsedAdd.server.command}${parsedAdd.server.args?.length ? ` ${parsedAdd.server.args.join(' ')}` : ''}`,
+            '  next /mcp tools',
           ].join('\n'));
         } catch (error) {
-          ctx.print(`MCP add failed: ${summarizeError(error)}`);
+          ctx.print(`MCP add failed ${summarizeError(error)}`);
         }
         return;
       }
@@ -360,10 +382,10 @@ export function registerMcpRuntimeCommands(registry: CommandRegistry): void {
         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}.`
+            ? `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)}`);
+          ctx.print(`MCP remove failed ${summarizeError(error)}`);
         }
         return;
       }
@@ -376,9 +398,9 @@ export function registerMcpRuntimeCommands(registry: CommandRegistry): void {
         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}.`);
+          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)}`);
+          ctx.print(`MCP reload failed ${summarizeError(error)}`);
         }
         return;
       }
@@ -389,22 +411,22 @@ export function registerMcpRuntimeCommands(registry: CommandRegistry): void {
           const effective = mcpApi.getEffectiveConfig(shellPaths);
           ctx.print([
             'MCP Config',
-            '  locations:',
+            '  locations',
             ...effective.locations.map((location) => `    ${location.scope}/${location.kind}${location.writable ? ' writable' : ' read-only'}  ${location.path}`),
-            `  effective servers: ${effective.servers.length}`,
+            `  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(',')}` : ''}`;
+              return `  - ${server.name}: ${server.command}${server.args?.length ? ` ${server.args.join(' ')}` : ''}  origin ${entry.source.scope}/${entry.source.kind}${envKeys.length ? ` envKeys=${envKeys.join(',')}` : ''}`;
             }),
             '',
-            'Add or update from inside Agent with explicit confirmation:',
+            'Add or update from inside Agent with explicit confirmation',
+            '  Open /mcp and choose Add or update server, or use Agent Workspace -> Tools & MCP -> Add MCP server.',
+            'Automation equivalent',
             '  /mcp add <name> <command> [args...] [--scope project|global] [--role <role>] [--trust <mode>] --yes',
-            'Example:',
-            '  /mcp add filesystem npx -y @modelcontextprotocol/server-filesystem . --scope project --role filesystem --trust constrained --yes',
           ].join('\n'));
         } catch (error) {
-          ctx.print(`MCP config read failed: ${summarizeError(error)}`);
+          ctx.print(`MCP config read failed ${summarizeError(error)}`);
         }
         return;
       }
@@ -418,12 +440,12 @@ export function registerMcpRuntimeCommands(registry: CommandRegistry): void {
         }
         if (action === 'approve') {
           if (!confirmation.yes) {
-            requireYesFlag(ctx, `approve MCP schema quarantine override for ${serverName}`, '/mcp quarantine <server> approve [operatorId] --yes');
+            requireYesFlag(ctx, `approve MCP tool-definition quarantine override for ${serverName}`, '/mcp quarantine <server> approve [operatorId] --yes');
             return;
           }
           const operatorId = commandArgs[3] || 'operator';
           mcpApi.approveSchemaQuarantine(serverName, operatorId);
-          ctx.print(`Approved MCP schema quarantine override for ${serverName} as ${operatorId}. Refresh is still recommended.`);
+          ctx.print(`Approved MCP tool-definition quarantine override for ${serverName} as ${operatorId}. Refresh is still recommended.`);
           return;
         }
         if (!confirmation.yes) {
@@ -432,7 +454,7 @@ export function registerMcpRuntimeCommands(registry: CommandRegistry): void {
         }
         const detail = commandArgs.slice(2).join(' ') || 'quarantined by operator';
         mcpApi.quarantineSchema(serverName, 'operator_flagged', detail);
-        ctx.print(`Quarantined MCP schema for ${serverName}.\nReason: ${detail}`);
+        ctx.print(`Quarantined MCP tool definitions for ${serverName}.\nReason: ${detail}`);
         return;
       }
 
@@ -446,8 +468,7 @@ 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 Agent with explicit confirmation:\n'
-          + '  /mcp add filesystem npx -y @modelcontextprotocol/server-filesystem . --scope project --role filesystem --yes\n'
+          + '\nOpen /mcp and choose Add or update server, or use Agent Workspace -> Tools & MCP -> Add MCP server.\n'
           + '\nFormat: { "servers": [{ "name": "my-server", "command": "npx", "args": ["-y", "@modelcontextprotocol/server-filesystem", "/tmp"] }] }'
         );
         return;
@@ -458,26 +479,22 @@ export function registerMcpRuntimeCommands(registry: CommandRegistry): void {
   });
 }
 
-type McpSecurityServer = ReturnType<NonNullable<NonNullable<CommandContext['clients']>['mcpApi']>['listServerSecurity']>[number];
-
 function formatMcpServerList(servers: readonly McpSecurityServer[]): string {
   const connected = servers.filter(s => s.connected);
   const disconnected = servers.filter(s => !s.connected);
   const lines: string[] = [`MCP Servers (${connected.length}/${servers.length} connected):`];
   for (const s of servers) {
-    const pathScope = s.allowedPaths.length > 0 ? ` paths=${s.allowedPaths.length}` : '';
-    const hostScope = s.allowedHosts.length > 0 ? ` hosts=${s.allowedHosts.length}` : '';
-    const freshness = ` freshness=${s.schemaFreshness}`;
-    const quarantine = s.schemaFreshness === 'quarantined' ? ` quarantine=${s.quarantineReason ?? 'unknown'}` : '';
-    lines.push(`  ${s.connected ? '[connected]   ' : '[disconnected]'}  ${s.name}  trust=${s.trustMode}  role=${s.role}${freshness}${quarantine}${pathScope}${hostScope}`);
+    const pathScope = s.allowedPaths.length > 0 ? ` paths ${s.allowedPaths.length}` : '';
+    const hostScope = s.allowedHosts.length > 0 ? ` hosts ${s.allowedHosts.length}` : '';
+    const freshness = ` status ${formatMcpFreshness(s.schemaFreshness)}`;
+    const quarantine = s.schemaFreshness === 'quarantined' ? ` review reason ${s.quarantineReason ?? 'unknown'}` : '';
+    lines.push(`  ${s.connected ? '[connected]   ' : '[disconnected]'}  ${s.name}  trust=${formatMcpTrustMode(s.trustMode)}  role=${formatMcpRole(s.role)}${freshness}${quarantine}${pathScope}${hostScope}`);
   }
   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] --yes" to add/update.');
-    lines.push('Run "/mcp reload --yes" after editing MCP config outside Agent.');
-    lines.push('Run "/mcp trust <server> <mode> --yes" to change trust mode, or "/mcp role <server> <role> --yes" to change its coherence role.');
-    lines.push('Run "/mcp quarantine <server> [detail] --yes" to block a server, or "/mcp quarantine <server> approve [operatorId] --yes" to approve a temporary override.');
+    lines.push('Open "/mcp" for the fullscreen MCP workspace with server status, tools, config paths, and confirmed add/remove/reload actions.');
+    lines.push('Use "/mcp tools" for a compact tool list, or "/mcp tools <server>" for one server.');
+    lines.push('Use Settings -> MCP for allow-all decisions; trust, role, and quarantine command actions still require explicit --yes confirmation.');
     lines.push('Use /settings -> MCP to explicitly enable allow-all for a server.');
   }
   if (disconnected.length > 0) {