@pellux/goodvibes-agent 0.1.117 → 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',
+      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 connected host integrations configured'
-        : serviceIssues.length === 0
+        : hostIntegrationIssues.length === 0
           ? `${services.length} host integration(s), ${oauthProviderCount + builtinSubscriptionProviderCount} oauth provider(s), ${activeSubscriptionCount} active subscription override(s)`
-          : `${serviceIssues.length} host integration configuration issue(s)`,
+          : `${hostIntegrationIssues.length} host integration configuration issue(s)`,
     },
     {
       severity: quarantinedPluginCount === 0 ? 'pass' : 'warn',
@@ -111,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'));
@@ -218,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>',
@@ -233,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;
         }
@@ -248,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:',
@@ -273,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) {
@@ -291,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) {
@@ -317,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;
       }
@@ -359,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;
       }
@@ -375,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;
       }
@@ -388,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:',
+            'Automation equivalent',
             '  /mcp add <name> <command> [args...] [--scope project|global] [--role <role>] [--trust <mode>] --yes',
           ].join('\n'));
         } catch (error) {
-          ctx.print(`MCP config read failed: ${summarizeError(error)}`);
+          ctx.print(`MCP config read failed ${summarizeError(error)}`);
         }
         return;
       }
@@ -417,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) {
@@ -431,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;
       }
 
@@ -456,18 +479,16 @@ 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('');

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

@@ -6,9 +6,9 @@ export function registerNotifyRuntimeCommands(registry: CommandRegistry): void {
   registry.register({
     name: 'notify',
     aliases: [],
-    description: 'Manage webhook notification URLs (ntfy.sh format)',
-    usage: 'add <url> --yes | remove <url> --yes | list | clear --yes | test --yes',
-    argsHint: 'list|add --yes|remove --yes|test --yes',
+    description: 'Manage and send configured Agent webhook notifications',
+    usage: 'add <url> --yes | remove <url> --yes | list | clear --yes | test --yes | send <message> --yes',
+    argsHint: 'list|add --yes|remove --yes|test --yes|send --yes',
     async handler(args, ctx) {
       const parsed = stripYesFlag(args);
       const commandArgs = [...parsed.rest];
@@ -18,8 +18,8 @@ export function registerNotifyRuntimeCommands(registry: CommandRegistry): void {
       const sub = commandArgs[0];
 
       if (!sub || sub === 'list') {
-        if (urls.length === 0) ctx.print('No webhook URLs configured.\nUse: /notify add <url>');
-        else ctx.print(`Webhook URLs (${urls.length}):\n${urls.map((u, i) => `  ${i + 1}. ${u}`).join('\n')}`);
+        if (urls.length === 0) ctx.print('No webhook URLs configured.\nUse /notify add <url>');
+        else ctx.print(`Webhook URLs (${urls.length})\n${urls.map((u, i) => `  ${i + 1}. ${u}`).join('\n')}`);
         return;
       }
 
@@ -34,11 +34,11 @@ export function registerNotifyRuntimeCommands(registry: CommandRegistry): void {
           return;
         }
         try { new URL(url); } catch {
-          ctx.print(`Invalid URL: ${url}`);
+          ctx.print(`Invalid URL ${url}`);
           return;
         }
         if (urls.includes(url)) {
-          ctx.print(`Already configured: ${url}`);
+          ctx.print(`Already configured ${url}`);
           return;
         }
         urls.push(url);
@@ -86,7 +86,7 @@ export function registerNotifyRuntimeCommands(registry: CommandRegistry): void {
           return;
         }
         if (urls.length === 0) {
-          ctx.print('No webhook URLs configured. Use: /notify add <url>');
+          ctx.print('No webhook URLs configured. Use /notify add <url>');
           return;
         }
         ctx.print(`Testing ${urls.length} webhook${urls.length !== 1 ? 's' : ''}...`);
@@ -96,7 +96,36 @@ export function registerNotifyRuntimeCommands(registry: CommandRegistry): void {
         return;
       }
 
-      ctx.print('Usage: /notify add <url> --yes | remove <url> --yes | list | clear --yes | test --yes');
+      if (sub === 'send') {
+        const message = commandArgs.slice(1).join(' ').trim();
+        if (!message) {
+          ctx.print('Usage: /notify send <message> --yes');
+          return;
+        }
+        if (!parsed.yes) {
+          requireYesFlag(ctx, 'send a notification to configured webhook targets', '/notify send <message> --yes');
+          return;
+        }
+        if (urls.length === 0) {
+          ctx.print('No webhook URLs configured. Use /notify add <url>');
+          return;
+        }
+        notifier.setUrls(urls);
+        const result = await notifier.send(message);
+        ctx.print([
+          'Notification sent',
+          `  attempted ${result.attempted}`,
+          `  delivered ${result.delivered}`,
+          `  failed ${result.failed}`,
+          ...result.results.slice(0, 20).map((delivery, index) => (
+            `  target ${index + 1} ${delivery.ok ? 'ok' : `failed${delivery.error ? ` (${delivery.error})` : ''}`}`
+          )),
+          ...(result.results.length > 20 ? [`  ${result.results.length - 20} more target(s) omitted.`] : []),
+        ].join('\n'));
+        return;
+      }
+
+      ctx.print('Usage: /notify add <url> --yes | remove <url> --yes | list | clear --yes | test --yes | send <message> --yes');
     },
   });
 }