feat: wire scaffold MCP server flow with Lambda-only host

Route CLI gateway-target command based on source: existing-endpoint
calls createExternalGatewayTarget, create-new calls createToolFromWizard.

Add mcpServerScaffold targetType for scaffolded Lambda MCP servers,
distinguishing them from external mcpServer endpoints and raw lambda
targets. CDK support for mcpServerScaffold comes in Task 15.

Restrict scaffold flow to Lambda-only compute host:
- TUI: skip host selection step (always Lambda)
- CLI: reject --host AgentCoreRuntime for create-new
- CLI: reject --host with existing-endpoint

Default --source to create-new and --host to Lambda when not specified.

Author: aidandaly24

src/cli/commands/add/actions.ts

@@ -23,7 +23,11 @@ import {
   createCredential,
   resolveCredentialStrategy,
 } from '../../operations/identity/create-identity';
-import { createGatewayFromWizard, createToolFromWizard } from '../../operations/mcp/create-mcp';
+import {
+  createExternalGatewayTarget,
+  createGatewayFromWizard,
+  createToolFromWizard,
+} from '../../operations/mcp/create-mcp';
 import { createMemory } from '../../operations/memory/create-memory';
 import { createRenderer } from '../../templates';
 import type { MemoryOption } from '../../tui/screens/generate/types';
@@ -322,6 +326,10 @@ export async function handleAddGatewayTarget(
 ): Promise<AddGatewayTargetResult> {
   try {
     const config = buildGatewayTargetConfig(options);
+    if (config.source === 'existing-endpoint') {
+      const result = await createExternalGatewayTarget(config);
+      return { success: true, toolName: result.toolName };
+    }
     const result = await createToolFromWizard(config);
     return { success: true, toolName: result.toolName, sourcePath: result.projectPath };
   } catch (err) {

src/cli/commands/add/validate.ts

@@ -189,15 +189,23 @@ export async function validateAddGatewayTargetOptions(options: AddGatewayTargetO
     return { valid: false, error: '--name is required' };
   }
 
-  if (options.type && options.type !== 'mcpServer' && options.type !== 'lambda') {
-    return { valid: false, error: 'Invalid type. Valid options: mcpServer, lambda' };
+  if (
+    options.type &&
+    options.type !== 'mcpServer' &&
+    options.type !== 'mcpServerScaffold' &&
+    options.type !== 'lambda'
+  ) {
+    return { valid: false, error: 'Invalid type. Valid options: mcpServer, mcpServerScaffold, lambda' };
   }
 
   if (options.source && options.source !== 'existing-endpoint' && options.source !== 'create-new') {
     return { valid: false, error: 'Invalid source. Valid options: existing-endpoint, create-new' };
   }
 
   if (options.source === 'existing-endpoint') {
+    if (options.host) {
+      return { valid: false, error: '--host is not applicable for existing endpoint targets' };
+    }
     if (!options.endpoint) {
       return { valid: false, error: '--endpoint is required when source is existing-endpoint' };
     }
@@ -218,6 +226,15 @@ export async function validateAddGatewayTargetOptions(options: AddGatewayTargetO
     return { valid: true };
   }
 
+  // Default source to create-new when not specified (scaffold flow)
+  options.source ??= 'create-new';
+  // Default host to Lambda for scaffolded targets
+  options.host ??= 'Lambda';
+
+  if (options.host !== 'Lambda') {
+    return { valid: false, error: 'Only Lambda is supported as compute host for scaffolded targets' };
+  }
+
   if (!options.language) {
     return { valid: false, error: '--language is required' };
   }

src/cli/operations/mcp/create-mcp.ts

@@ -310,7 +310,7 @@ export async function createToolFromWizard(config: AddGatewayTargetConfig): Prom
   // Create a single target with all tool definitions
   const target: AgentCoreGatewayTarget = {
     name: config.name,
-    targetType: config.host === 'AgentCoreRuntime' ? 'mcpServer' : 'lambda',
+    targetType: config.host === 'AgentCoreRuntime' ? 'mcpServer' : 'mcpServerScaffold',
     toolDefinitions: toolDefs,
     compute:
       config.host === 'Lambda'

src/cli/tui/screens/mcp/useAddGatewayTargetWizard.ts

@@ -13,7 +13,8 @@ function getSteps(source?: 'existing-endpoint' | 'create-new'): AddGatewayTarget
   if (source === 'existing-endpoint') {
     return ['name', 'source', 'endpoint', 'gateway', 'confirm'];
   }
-  return ['name', 'source', 'language', 'gateway', 'host', 'confirm'];
+  // Phase 1: Lambda is the only compute host, so skip host selection
+  return ['name', 'source', 'language', 'gateway', 'confirm'];
 }
 
 function deriveToolDefinition(name: string): ToolDefinition {
@@ -91,13 +92,8 @@ export function useAddGatewayTargetWizard(existingGateways: string[] = []) {
 
   const setGateway = useCallback((gateway: string) => {
     setConfig(c => {
-      const isExternal = c.source === 'existing-endpoint';
       const isSkipped = gateway === SKIP_FOR_NOW;
-      if (isExternal || isSkipped) {
-        setStep('confirm');
-      } else {
-        setStep('host');
-      }
+      setStep('confirm');
       return { ...c, gateway: isSkipped ? undefined : gateway };
     });
   }, []);

src/schema/schemas/__tests__/mcp.test.ts

@@ -14,7 +14,7 @@ import {
 import { describe, expect, it } from 'vitest';
 
 describe('GatewayTargetTypeSchema', () => {
-  it.each(['lambda', 'mcpServer', 'openApiSchema', 'smithyModel'])('accepts "%s"', type => {
+  it.each(['lambda', 'mcpServer', 'mcpServerScaffold', 'openApiSchema', 'smithyModel'])('accepts "%s"', type => {
     expect(GatewayTargetTypeSchema.safeParse(type).success).toBe(true);
   });
 
@@ -492,6 +492,27 @@ describe('AgentCoreGatewayTargetSchema with outbound auth', () => {
     });
     expect(result.success).toBe(false);
   });
+
+  it('mcpServerScaffold target without compute fails', () => {
+    const result = AgentCoreGatewayTargetSchema.safeParse({
+      name: 'myTarget',
+      targetType: 'mcpServerScaffold',
+    });
+    expect(result.success).toBe(false);
+  });
+
+  it('mcpServerScaffold target with compute passes', () => {
+    const result = AgentCoreGatewayTargetSchema.safeParse({
+      name: 'myTarget',
+      targetType: 'mcpServerScaffold',
+      compute: {
+        host: 'Lambda',
+        implementation: { language: 'Python', path: 'app/mcp/myTarget', handler: 'handler.handler' },
+        pythonVersion: 'PYTHON_3_12',
+      },
+    });
+    expect(result.success).toBe(true);
+  });
 });
 
 describe('AgentCoreMcpSpecSchema', () => {

src/schema/schemas/mcp.ts

@@ -8,7 +8,13 @@ import { z } from 'zod';
 // MCP-Specific Schemas
 // ============================================================================
 
-export const GatewayTargetTypeSchema = z.enum(['lambda', 'mcpServer', 'openApiSchema', 'smithyModel']);
+export const GatewayTargetTypeSchema = z.enum([
+  'lambda',
+  'mcpServer',
+  'mcpServerScaffold',
+  'openApiSchema',
+  'smithyModel',
+]);
 export type GatewayTargetType = z.infer<typeof GatewayTargetTypeSchema>;
 
 // ============================================================================
@@ -307,6 +313,13 @@ export const AgentCoreGatewayTargetSchema = z
         path: ['toolDefinitions'],
       });
     }
+    if (data.targetType === 'mcpServerScaffold' && !data.compute) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: 'Scaffolded MCP Server targets require compute configuration.',
+        path: ['compute'],
+      });
+    }
     if (data.outboundAuth && data.outboundAuth.type !== 'NONE' && !data.outboundAuth.credentialName) {
       ctx.addIssue({
         code: z.ZodIssueCode.custom,