OK Suresh, sorry about the delay, but here's the code in two parts.  Firstly, please note that I am certainly no star Java programmer and there will be scope for improvement.  It's stuff I have built over time and is subject to steady improvement as my knowledge improves and time allows.  Secondly there may be a few things directly related to the setup in my organisation, so some things may not be generalised as well as they might be or may refer to internal processes such as Governance.

There are still subsets of ClearQuest users that still refuse to adopt team concert without this email reader feature and won't accept the answer to pay for a vendor tool to do this.  This is so common in many tool sets, yet IBM continues to ignore it's customer base.

IBM themselves use a third-party offering but fortunately this isn't terribly difficult to write. I've done this recently and would be happy to share - it's 'work in progress' code and not the finished article, but what's there works.  

 And here's the other part, this time preformatted!

package com.nbs.nsl.utility;

import com.nbs.nsl.utility.Common;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.net.URI;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Properties;
import java.util.regex.Pattern;
import javax.mail.Address;
import javax.mail.Flags;
import javax.mail.Folder;
import javax.mail.Message;
import javax.mail.MessagingException;
import javax.mail.Multipart;
import javax.mail.Part;
import javax.mail.Session;
import javax.mail.Store;
import javax.mail.internet.MimeBodyPart;
import com.ibm.team.process.client.IProcessClientService;
import com.ibm.team.process.client.IProcessItemService;
import com.ibm.team.process.common.IProjectArea;
import com.ibm.team.process.common.IProjectAreaHandle;
import com.ibm.team.repository.client.ITeamRepository;
import com.ibm.team.repository.client.TeamPlatform;
import com.ibm.team.repository.client.ITeamRepository.ILoginHandler;
import com.ibm.team.repository.client.ITeamRepository.ILoginHandler.ILoginInfo;
import com.ibm.team.repository.common.IContributor;
import com.ibm.team.repository.common.TeamRepositoryException;
import com.ibm.team.workitem.common.model.IWorkItem;
import org.apache.logging.log4j.Level;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.io.IoBuilder;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.NullProgressMonitor;
// import org.jsoup.Jsoup;
public class CreateWorkItemsFromIncomingEmails {
/**
 * Monitor a mailbox and create a work item for each new incoming email
 * 
 * - 'new' emails will be ones, read or unread, that arrived since that timestamp 
 * - ignore mails with RE: or FW: in the subject line so we don't get multiple work items for 
 * the same thing
 * - move an email to a target folder once its work item has been created 
 * 
 * NOTES
 * Firstly, the mailbox must be POP/IMAP enabled.  Do this via an eURF.
 * 
 */
private static String me = "CreateWorkItemsFromIncomingEmails";
private static Logger log;

public static void main(String[] args) throws TeamRepositoryException {
    boolean result = false;
    // Set up log4j2 to redirect all output to the log file.  This must be the first thing we do.
    String logPath          = args[4];
    String logLevel         = args[5]; 
    // Log level: "The level may be configured with one of TRACE, DEBUG, INFO, WARN, ERROR, ALL or OFF. 
    // If no level is specified it will default to ERROR."
    System.setProperty("appName", me);  
    System.setProperty("logPath", logPath);
    System.setProperty("logLevel", logLevel);
    log = (Logger) LogManager.getLogger();
    System.setErr(IoBuilder.forLogger(LogManager.getRootLogger()).setLevel(Level.ERROR).buildPrintStream());    // redirects STDERR to log4j2
    System.setOut(IoBuilder.forLogger(LogManager.getRootLogger()).setLevel(Level.INFO).buildPrintStream());     // redirects STDOUT to log4j2
    log.info(me + " starting");

    TeamPlatform.startup();
    try {
        result = run(args);
    } catch (TeamRepositoryException x) {
        x.printStackTrace();
        result = false;
    } finally {
        TeamPlatform.shutdown();
    }       
    if (!result)
        System.exit(1);
}

private static boolean run(String[] args) throws TeamRepositoryException {

    if (args.length != 16) {
        log.fatal("ERROR - wrong number of parameters. 16 expected: <repositoryURI> <repositoryUserId> <password> <project area> <Log File Path> <Log Level> <Work Path> "+
                "<mail server> <mail account> <mail password> <inbox name> <movetobox name> <workitem type> <category> <timeline ID> <iterationID>");
        return false;
    }

    String repositoryURI    = args[0];
    String repoUserId       = args[1];
    String password         = args[2];
    String paName           = args[3];
    String logPath          = args[4];
    String workPath         = args[6];
    String mailServer       = args[7];
    String mailAccount      = args[8];
    String mailPassword     = args[9];
    String inbox            = args[10];
    String movebox          = args[11];
    String workitemType     = args[12];
    String categoryName     = args[13];
    String timelineId       = args[14];
    String iterationId      = args[15];

    log.info("Repository URI:      " + repositoryURI);
    log.info("Repository User ID:  " + repoUserId);
    log.info("Project Area:        " + paName);
    log.info("Log file path:       " + logPath);
    log.info("Work path:           " + workPath);
    log.info("Mail server:         " + mailServer);
    log.info("Mail account:        " + mailAccount);
    log.info("Inbox name:          " + inbox);
    log.info("Move to folder:      " + movebox);
    log.info("Workitem Type:       " + workitemType);
    log.info("Category:            " + categoryName);
    log.info("Timeline ID:         " + timelineId);
    log.info("Iteration ID:        " + iterationId);

    // Ensure we can login before we do anything else
    ITeamRepository repo = TeamPlatform.getTeamRepositoryService().getTeamRepository(repositoryURI);
    repo.registerLoginHandler(new LoginHandler(repoUserId, password));
    repo.login(null);       
    log.info("Logged in as:        " + repo.loggedInContributor().getName());

    try {                   
        IProcessClientService processClient = (IProcessClientService) repo.getClientLibrary(IProcessClientService.class);
        IProcessItemService processItem = (IProcessItemService) repo.getClientLibrary(IProcessItemService.class);

        URI uri = URI.create(paName.replaceAll(" ", "%20"));
        IProjectArea projectArea = (IProjectArea) processClient.findProcessArea(uri, null, null);
        if (projectArea == null) {
            log.info("Project Area " + paName + " Does NOT exist.");
            throw new TeamRepositoryException("Project Area " + paName + " Does NOT exist");
        }           
        // Create a mutable copy of the project area
        projectArea = (IProjectArea) processItem.getMutableCopy(projectArea);
        IProjectAreaHandle paHdl = projectArea.getProjectArea();

        processInbox(repo, paHdl, mailServer, mailAccount, mailPassword, inbox, movebox, workitemType, categoryName, timelineId, iterationId, workPath);

    } catch (FileNotFoundException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    } catch (MessagingException m) {
        m.printStackTrace();
    } catch (Exception e) {
        e.printStackTrace();
    }
    finally {
    }               
    repo.logout();
    log.info("*** Finished ***");
    return true;        
}

private static class LoginHandler implements ILoginHandler, ILoginInfo {
    private String fUserId;
    private String fPassword;

    private LoginHandler(String userId, String password) {
        fUserId = userId;
        fPassword = password;
    }
    public String getUserId() {
        return fUserId;
    }
    public String getPassword() {
        return fPassword;
    }
    public ILoginInfo challenge(ITeamRepository repository) {
        return this;
    }
}
private static void processInbox (ITeamRepository repo, IProjectAreaHandle paHdl, String mailServer, String mailAccount, String mailPassword, 
        String inbox, String movebox, String workitemType,  String categoryName, String timelineId, String iterationId, String workPath)
        throws TeamRepositoryException, IOException, MessagingException, Exception {

        log.info("processInbox Entry");

        Properties props = System.getProperties();

        // POP Connection - for accessing a single, fixed-named INBOX only.  These settings work.

/          props.setProperty("mail.pop3.host", mailServer); 
            props.setProperty("mail.pop3.port", "110");
            props.setProperty("mail.pop3.starttls.enable", "true");
            props.setProperty("mail.pop3.socketFactory.fallback", "false");
            Session session = Session.getDefaultInstance(props);                  

            Store mailStore = session.getStore("pop3");
            session.setDebug(false);
            mailStore.connect(mailAccount, mailPassword);/
        // IMAP Connection - far more flexible      
        props.setProperty("mail.imap.host", mailServer);
        props.setProperty("mail.imap.port", "143");
        props.setProperty("mail.imap.starttls.enable", "true");
        props.setProperty("mail.imap.socketFactory.fallback", "false");
        props.setProperty("mail.imaps.socketFactory.port", "143");
        Session session = Session.getDefaultInstance(props);
        Store mailStore = session.getStore("imap");
        session.setDebug(false);
        mailStore.connect(mailAccount, mailPassword);

        Folder ibFolder = mailStore.getFolder(inbox);
        ibFolder.open(Folder.READ_WRITE);

        ArrayList<String> attribIds   = new ArrayList<String>();
        ArrayList<Object> attribObjs  = new ArrayList<Object>();
        ArrayList<String> contentTypes    = new ArrayList<String>();
        ArrayList<String> contentFilenames    = new ArrayList<String>();
        ArrayList<String> encodings       = new ArrayList<String>();
        ArrayList<Pattern> ignoreList = new ArrayList<Pattern>();
        ignoreList.add(Pattern.compile("^RE: .*"));
        ignoreList.add(Pattern.compile("^FW: .*"));
        ignoreList.add(Pattern.compile("^Invitation: .*"));
        ignoreList.add(Pattern.compile("^Accepted: .*"));
        ignoreList.add(Pattern.compile("^Confirmed: .*"));
        ignoreList.add(Pattern.compile("^Tentative: .*"));
        ignoreList.add(Pattern.compile("^Declined: .*"));
        ignoreList.add(Pattern.compile("^New Time Proposed: .*"));

        String subject;
        String sender;
        IProgressMonitor monitor = new NullProgressMonitor();

        // Open destination folder, create if reqd.  IMAP only
        Folder destfolder = mailStore.getFolder(movebox);
        if (!destfolder.exists()) {
           destfolder.create(Folder.HOLDS_MESSAGES);
        }
        destfolder.open(Folder.READ_WRITE);

        Message[] inMessages = ibFolder.getMessages();

        if (inMessages .length != 0) {
            messageLoop:
            for (int i = 0; i < inMessages.length; i++) {

//                  if (i > 0) {break;}      // * TESTING - look at first n+1 messages * 
                log.info("***** Message Number " + Integer.toString(i));
                sender = "** UNKNOWN **";
                Address[] a;
                // FROM
                if ((a = inMessages[i].getFrom()) != null) {
                    for (int j = 0; j < a.length; j++) {
                        sender = a[j].toString();
                        log.info("Message From: " + sender);                        
                    }
                }
                subject = inMessages[i].getSubject();
                log.info("Message Subject: " + subject);
                Date receivedDate = inMessages[i].getReceivedDate();
                Date sentDate = inMessages[i].getSentDate(); 
                SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

                if (receivedDate != null) {
                    log.info("Message Received: " + df.format(receivedDate));
                }                   
                log.info("Message Sent: " + df.format(sentDate));

                for (int j = 0; j < ignoreList.size(); j++) {
                    if (ignoreList.get(j).matcher(subject).matches()) {
                        log.info("Message will be ** IGNORED **");
                        continue messageLoop;
                    }
                }
                // At this point we have a message we want to deal with.
                // Move the message and if that's successful, create a work item using its data
                Message[] moveMessages = new Message[1];
                moveMessages[0] = inMessages[i];
                log.info("Copying message");
                ibFolder.copyMessages(moveMessages, destfolder);
                log.info("Deleting message");
                inMessages[i].setFlag(Flags.Flag.DELETED, true);

                attribIds.clear();
                attribObjs.clear();
                contentTypes.clear();
                contentFilenames.clear();

                attribIds.add("description");
                attribObjs.add("Originator: " + sender + "\n\n" + getMessageParts(inMessages[i], workPath, contentTypes, contentFilenames, encodings));

                IWorkItem newWI = Common.createWorkItem(repo, paHdl, workitemType, subject, categoryName, timelineId, iterationId, 
                    attribIds, attribObjs, null, monitor, log);

                if (contentFilenames.size() > 0) {
                    log.info("Adding the attachments to the Work Item");

                    for (int j = 0; j < contentFilenames.size(); j++) {
                        Common.attachFile(repo, newWI, contentFilenames.get(j), contentTypes.get(j), encodings.get(j), monitor, log);
                    }

                } 
                if (!subscribeSenderToWorkItem(sender, newWI, repo, monitor)) {
                    // Do something.  What?
                }
            }
        }
        ibFolder.close(true);       // Expunges messages marked for deletion
        log.info("processInbox Exit");
        return; 
    }

private static boolean subscribeSenderToWorkItem (String sender, IWorkItem workItem, ITeamRepository repo, IProgressMonitor monitor) 
        throws TeamRepositoryException, IOException {
    log.info("subscribeSenderToWorkItem entry.");

    sender = sender.replaceAll("\"", "");
    int pos = sender.indexOf("<");
    if (pos > 0) {sender = sender.substring(0, pos);}
    log.info("Adjusted sender: " + sender);

    List<IContributor> contributors = Common.getContributorByName(repo, sender, monitor, log);

    if (contributors.size() == 1) {
        Common.addSubscriberToWorkitem(workItem, contributors.get(0), monitor, log);
        log.info("subscribeSenderToWorkItem exit.");
        return(true);
    }
    else {
        log.info("**" + sender + "could not be added as a subscriber to the work item **");
        log.info("subscribeSenderToWorkItem exit.");
        return(false);
    }       
}

public static String getMessageParts(Part p, String workPath, ArrayList<String> contentTypes, ArrayList<String> contentFilenames, ArrayList<String> encodings) 
        throws Exception {

    // Build arrays of attachments and their content types
    log.info("getParts entry.");              
    String contentType = p.getContentType();
    log.info("Content type is " + contentType);
    String msgtext = "";

    //check if the content is plain text
    if (p.isMimeType("text/plain")) {
        log.info("plain text");
        Object content = p.getContent();
        if (content != null) {
            msgtext = content.toString();
        }
        return(msgtext);
    }
    else if (p.isMimeType("text/html")) {
        String html = (String) p.getContent();
        msgtext = org.jsoup.Jsoup.parse(html).text();
        return(msgtext);
    }
    //check if the content has attachments or other bits and pieces
    else if (contentType.contains("multipart")) {
        log.info("Multipart message");

        Multipart multiPart = (Multipart) p.getContent();

        for (int i = 0; i < multiPart.getCount(); i++) {
            MimeBodyPart part = (MimeBodyPart) multiPart.getBodyPart(i);
            contentType = part.getContentType();
            String disposition = part.getDisposition();
            String file = part.getFileName();
            if (part.isMimeType("text/plain")) {
                log.info("part is plain text");
                Object content = part.getContent();
                if (content != null) {
                    msgtext = msgtext + "\n" + content.toString();
                }
            }
            else if (part.isMimeType("text/html")) {
                String html = (String) part.getContent();
                msgtext = msgtext + org.jsoup.Jsoup.parse(html).text();
            }
            else if (part.isMimeType("multipart/*")) {
                msgtext = msgtext + "\n" + getMessageParts(part, workPath, contentTypes, contentFilenames, encodings);
            }
            // Attachments 
            else if (disposition != null && Part.ATTACHMENT.equalsIgnoreCase(disposition)) {
                // this part is regular file attachment  
                log.info("part is a file attachment. Filename: "+file);
                // Ensure the temp file does not exist before saving it
                File f = new File(workPath, file);
                f.delete();
                String filename = workPath + "/" + file;
                part.saveFile(filename);
                contentTypes.add(Common.getContentTypeByFileName(filename));
                contentFilenames.add(filename);
                encodings.add(part.getEncoding());
                log.info("Content Type: "+Common.getContentTypeByFileName(filename));
                log.info("Encoding: "+part.getEncoding());
            }
            // Inline images as attachments
            else if (disposition != null && Part.INLINE.equalsIgnoreCase(disposition)) {
                log.info("part is an inline image. Filename: "+file);
                // Ensure the temp file does not exist before saving it
                File f = new File(workPath, file);
                f.delete();
                String filename = workPath + "/" + file;                        
                part.saveFile(filename);
                contentTypes.add(part.getContentType());
                contentFilenames.add(filename);
                encodings.add(part.getEncoding());
                log.info("Content Type: "+part.getContentType());
                log.info("Encoding: "+part.getEncoding());
            }
            else {
                Object o = p.getContent();
                if (o instanceof String) {
                    log.info("part is a string");
                    return(msgtext + "\n" + o.toString());
                }
                else if (o instanceof InputStream) {
                    log.info("part is an input stream");

/                      InputStream is = (InputStream) o;
                        is = (InputStream) o;
                        int c;
                        while ((c = is.read()) != -1)
                           System.out.write(c);
                     }/                  

                    }                 

                    log.info("Could not process part");
                    log.info("message part we can't handle.  BodyPart disposition: "+disposition+"  BodyPart description: "+part.getDescription());
                }
            }
            return (msgtext);
        } 
    else {
        Object o = p.getContent();
        if (o instanceof String) {
            log.info("part is a string");
            return(msgtext + "\n" + o.toString());
        }
        else if (o instanceof InputStream) {
            log.info("part is an input stream");

/              InputStream is = (InputStream) o;
                is = (InputStream) o;
                int c;
                while ((c = is.read()) != -1)
                   System.out.write(c);/
             }         

             log.info("Could not process part");        // Probably HTML
             return(msgtext + "\n*** Could not process this part of the message body - check the original email");
        }
    }
}