diff --git a/common/fileview2/fvdisksource.cpp b/common/fileview2/fvdisksource.cpp
index 068e526f2ff..5c27abf366b 100644
--- a/common/fileview2/fvdisksource.cpp
+++ b/common/fileview2/fvdisksource.cpp
@@ -678,7 +678,8 @@ bool TranslatedDiskDataSource::init()
 bool TranslatedDiskDataSource::compileHelperWU()
 {
     submitWorkUnit(helperWuid, username, password);
-    return waitForWorkUnitToCompile(helperWuid);
+    WUState state = waitForWorkUnitToCompile(helperWuid);
+    return isCompiled(state);
 }
 
 //---------------------------------------------------------------------------
diff --git a/common/workunit/workunit.cpp b/common/workunit/workunit.cpp
index e00c4372ad9..b3f5e91da5f 100644
--- a/common/workunit/workunit.cpp
+++ b/common/workunit/workunit.cpp
@@ -13182,25 +13182,16 @@ extern WORKUNIT_API WUState secWaitForWorkUnitToComplete(const char * wuid, ISec
     return WUStateUnknown;
 }
 
-extern bool waitForWorkUnitToCompile(const char * wuid, int timeout)
+extern WUState waitForWorkUnitToCompile(const char * wuid, int timeout)
 {
-    switch(globalFactory->waitForWorkUnit(wuid, (unsigned) timeout, true, { WUStateWait }))
-    {
-    case WUStateCompiled:
-    case WUStateCompleted:
-    case WUStateWait:
-    case WUStateUploadingFiles:
-        return true;
-    default:
-        return false;
-    }
+    return globalFactory->waitForWorkUnit(wuid, (unsigned) timeout, true, { WUStateWait });
 }
 
-extern WORKUNIT_API bool secWaitForWorkUnitToCompile(const char *wuid, ISecManager *secmgr, ISecUser *secuser, int timeout)
+extern WORKUNIT_API WUState secWaitForWorkUnitToCompile(const char *wuid, ISecManager *secmgr, ISecUser *secuser, int timeout)
 {
     if (checkWuSecAccess(wuid, secmgr, secuser, SecAccess_Read, "Wait for Compile", false, true))
         return waitForWorkUnitToCompile(wuid, timeout);
-    return false;
+    return WUStateUnknown;
 }
 
 extern WORKUNIT_API bool secDebugWorkunit(const char *wuid, ISecManager *secmgr, ISecUser *secuser, const char *command, StringBuffer &response)
diff --git a/common/workunit/workunit.hpp b/common/workunit/workunit.hpp
index f9a55b0559d..365468ff483 100644
--- a/common/workunit/workunit.hpp
+++ b/common/workunit/workunit.hpp
@@ -1695,9 +1695,9 @@ inline bool isWorkunitDAToken(const char * distributedAccessToken)
 
 //returns a state code.  WUStateUnknown == timeout
 extern WORKUNIT_API WUState waitForWorkUnitToComplete(const char * wuid, int timeout = -1, std::list<WUState> expectedStates = {});
-extern WORKUNIT_API bool waitForWorkUnitToCompile(const char * wuid, int timeout = -1);
+extern WORKUNIT_API WUState waitForWorkUnitToCompile(const char * wuid, int timeout = -1);
 extern WORKUNIT_API WUState secWaitForWorkUnitToComplete(const char * wuid, ISecManager *secmgr, ISecUser *secuser, int timeout = -1, std::list<WUState> expectedStates = {});
-extern WORKUNIT_API bool secWaitForWorkUnitToCompile(const char *wuid, ISecManager *secmgr, ISecUser *secuser, int timeout = -1);
+extern WORKUNIT_API WUState secWaitForWorkUnitToCompile(const char *wuid, ISecManager *secmgr, ISecUser *secuser, int timeout = -1);
 extern WORKUNIT_API bool secDebugWorkunit(const char *wuid, ISecManager *secmgr, ISecUser *secuser, const char *command, StringBuffer &response);
 extern WORKUNIT_API WUState getWorkUnitState(const char* state);
 extern WORKUNIT_API IWorkflowScheduleConnection * getWorkflowScheduleConnection(char const * wuid);
@@ -1705,6 +1705,7 @@ extern WORKUNIT_API const char *skipLeadingXml(const char *text);
 extern WORKUNIT_API bool isArchiveQuery(const char * text);
 extern WORKUNIT_API bool isQueryManifest(const char * text);
 extern WORKUNIT_API IPropertyTree * resolveDefinitionInArchive(IPropertyTree * archive, const char * path);
+inline bool isCompiled(WUState state) { return state == WUStateCompiled || state == WUStateCompleted; }
 
 inline bool isLibrary(IConstWorkUnit * wu) { return wu->getApplicationValueInt("LibraryModule", "interfaceHash", 0) != 0; }
 
diff --git a/ecl/eclcmd/eclcmd_common.cpp b/ecl/eclcmd/eclcmd_common.cpp
index f513750b99e..db46d75426c 100644
--- a/ecl/eclcmd/eclcmd_common.cpp
+++ b/ecl/eclcmd/eclcmd_common.cpp
@@ -753,6 +753,10 @@ eclCmdOptionMatchIndicator EclCmdWithEclTarget::matchCommandLineOption(ArgvItera
         return EclCmdOptionMatch;
     if (iter.matchOption(optTargetCluster, ECLOPT_CLUSTER_DEPRECATED)||iter.matchOption(optTargetCluster, ECLOPT_CLUSTER_DEPRECATED_S))
         return EclCmdOptionMatch;
+    if (iter.matchOption(optWaitTime, ECLOPT_WAIT))
+        return EclCmdOptionMatch;
+    if (iter.matchFlag(optPoll, ECLOPT_POLL))
+        return EclCmdOptionMatch;
     //Process options which should be passed straight through to eclcc
     StringBuffer temp;
     if (iter.matchOptionText(temp, ECLOPT_FETCH_REPOS, true, false) || iter.matchOptionText(temp, ECLOPT_UPDATE_REPOS, true, false) ||
diff --git a/ecl/eclcmd/eclcmd_common.hpp b/ecl/eclcmd/eclcmd_common.hpp
index 16912c5566e..957d7af21b1 100644
--- a/ecl/eclcmd/eclcmd_common.hpp
+++ b/ecl/eclcmd/eclcmd_common.hpp
@@ -21,6 +21,7 @@
 #include "ws_workunits.hpp"
 #include "ws_fs.hpp"
 #include "eclcc.hpp"
+#include "workunit.hpp"
 
 //=========================================================================================
 
@@ -311,6 +312,7 @@ class EclCmdCommon : implements IEclCommand, public CInterface
         setRpcRequestTimeouts(rpc, waitMS, optWaitConnectMs, optWaitReadSec);
         setRpcSSLOptions(rpc, optSSL, optClientCert, optClientPrivateKey, optCACert, optAcceptSelfSigned);
     }
+    void checkFeatures(IClientWsWorkunits *client, bool &useCompression, int &major, int &minor, int &point, unsigned waitMs, unsigned waitConnectMs, unsigned waitReadSec);
 
     virtual void usage()
     {
@@ -359,7 +361,7 @@ class EclCmdCommon : implements IEclCommand, public CInterface
 class EclCmdWithEclTarget : public EclCmdCommon
 {
 public:
-    EclCmdWithEclTarget() : optResultLimit((unsigned)-1), paramCount(0), optNoArchive(false), optLegacy(false), optDebug(false), optCheckDirty(false)
+    EclCmdWithEclTarget() : optResultLimit((unsigned)-1), paramCount(0), optWaitTime((unsigned)-1), optNoArchive(false), optLegacy(false), optDebug(false), optCheckDirty(false), optPoll(false)
     {
     }
     virtual eclCmdOptionMatchIndicator matchCommandLineOption(ArgvIterator &iter, bool finalAttempt=false);
@@ -367,6 +369,7 @@ class EclCmdWithEclTarget : public EclCmdCommon
     bool getFullAttributePath(StringBuffer & result);
     bool setTarget(const char *target);
     bool setParam(const char *in, bool final);
+    bool doDeploy(IClientWsWorkunits *client, unsigned waitMs, const char *cluster, const char *name, StringBuffer *wuid, StringBuffer *wucluster, bool noarchive, bool displayWuid, bool compress, bool protect);
 
     virtual void usage()
     {
@@ -380,6 +383,8 @@ class EclCmdWithEclTarget : public EclCmdCommon
             "   -f-<option>[=value]    Set an eclcc command line option (single '-')\n"
             "   -f--<option>[=value]   Set an eclcc command line option (double '-')\n"
             "   -Dname=value           Override the definition of a global attribute 'name'\n"
+            "   --wait=<ms>            Max time to wait in milliseconds\n"
+            "   --poll                 Poll for results, rather than remain connected\n"
             " eclcc options (everything following):\n"
         );
         for (unsigned line=0; line < _elements_in(helpText); line++)
@@ -407,6 +412,19 @@ class EclCmdWithEclTarget : public EclCmdCommon
         }
         EclCmdCommon::usage();
     }
+
+protected:
+    int checkComplete(IClientWsWorkunits* client, IClientWUWaitRequest* req);
+    WUState checkCompiled(IClientWsWorkunits* client, IClientWUWaitRequest* req);
+    WUState pollForCompile(IClientWsWorkunits* client, const char *wuid, unsigned startTimeMs);
+
+    int getInitialRunWait()
+    {
+        if (!optPoll)
+            return optWaitTime;
+        return (optWaitTime < 10000) ? optWaitTime : 10000; //stay connected for the first 10 seconds even if polling
+    }
+
 public:
     StringAttr param;
     StringAttr optTargetCluster;
@@ -424,12 +442,14 @@ class EclCmdWithEclTarget : public EclCmdCommon
     IArrayOf<IEspNamedValue> definitions;
     unsigned optResultLimit;
     unsigned paramCount;
+    unsigned optWaitTime;
     bool optNoArchive;
     bool optLegacy;
     bool optDebug;
     bool optCheckDirty;
     bool optFastSyntax = false;
     bool optNoStdInc = false;
+    bool optPoll;
     StringArray extraOptions;
 };
 
diff --git a/ecl/eclcmd/eclcmd_core.cpp b/ecl/eclcmd/eclcmd_core.cpp
index cb39d951d5b..82ce99d2a04 100644
--- a/ecl/eclcmd/eclcmd_core.cpp
+++ b/ecl/eclcmd/eclcmd_core.cpp
@@ -67,12 +67,41 @@ void expandDefintionsAsDebugValues(const IArrayOf<IEspNamedValue> & definitions,
 
 }
 
-void checkFeatures(EclCmdCommon &cmd, IClientWsWorkunits *client, bool &useCompression, int &major, int &minor, int &point, unsigned waitMs, unsigned waitConnectMs, unsigned waitReadSec)
+static bool isSoapRpcException(IException *E)
+{
+    StringBuffer msg;
+    const char *finger = E->errorMessage(msg).str();
+    if (strncmp(finger, "SOAP ", 5))
+        return false;
+    finger+=5;
+    if (!strncmp(finger, "rpc error", 9))
+        return true;
+    if (!strncmp(finger, "Connection error", 16))
+        return true;
+    return false;
+}
+
+static unsigned nextWait(unsigned wait, unsigned waited)
+{
+    if (waited < 5000)
+        return 1000;
+    if (waited < 30000)
+        return 5000;
+    if (waited < 60000)
+        return 10000;
+    if (waited < 120000)
+        return 30000;
+    return 60000;
+}
+
+//-------------------------------------------------------------------------------
+
+void EclCmdCommon::checkFeatures(IClientWsWorkunits *client, bool &useCompression, int &major, int &minor, int &point, unsigned waitMs, unsigned waitConnectMs, unsigned waitReadSec)
 {
     try
     {
         Owned<IClientWUCheckFeaturesRequest> req = client->createWUCheckFeaturesRequest();
-        cmd.setRpcOptions(req->rpc(), waitMs);
+        setRpcOptions(req->rpc(), waitMs);
         Owned<IClientWUCheckFeaturesResponse> resp = client->WUCheckFeatures(req);
         useCompression = resp->getDeployment().getUseCompression();
         major = resp->getBuildVersionMajor();
@@ -88,32 +117,161 @@ void checkFeatures(EclCmdCommon &cmd, IClientWsWorkunits *client, bool &useCompr
     }
 }
 
-bool doDeploy(EclCmdWithEclTarget &cmd, IClientWsWorkunits *client, unsigned waitMs, const char *cluster, const char *name, StringBuffer *wuid, StringBuffer *wucluster, bool noarchive, bool displayWuid, bool compress, bool protect)
+static bool isFinalRunState(WUState state)
+{
+    switch (state)
+    {
+    case WUStateUnknown:
+    case WUStateArchived:
+    case WUStateAborting:
+    case WUStateCompleted:
+    case WUStateFailed:
+    case WUStateAborted:
+        return true;
+    }
+    return false;
+}
+
+static bool isFinalCompileState(WUState state)
+{
+    if (state == WUStateCompiled)
+        return true;
+    return isFinalRunState(state);
+}
+
+int EclCmdWithEclTarget::checkComplete(IClientWsWorkunits* client, IClientWUWaitRequest* req)
+{
+    try
+    {
+        Owned<IClientWUWaitResponse> resp = client->WUWaitComplete(req);
+        if (resp->getExceptions().ordinality())
+            throw LINK(&resp->getExceptions());
+        return resp->getStateID();
+    }
+    catch (IJSOCK_Exception *E)
+    {
+        outputExceptionEx(*E);
+        E->Release();
+    }
+    catch (IException *E)
+    {
+        if (!isSoapRpcException(E))
+            throw E;
+        outputExceptionEx(*E);
+        E->Release();
+    }
+
+    fputs("Still polling...\n", stderr);
+    return WUStateUnknown; //socket issue, keep polling
+}
+
+
+WUState EclCmdWithEclTarget::checkCompiled(IClientWsWorkunits* client, IClientWUWaitRequest* req)
+{
+    try
+    {
+        Owned<IClientWUWaitResponse> resp = client->WUWaitCompiled(req);
+        if (resp->getExceptions().ordinality())
+            throw LINK(&resp->getExceptions());
+        return (WUState)resp->getStateID();
+    }
+    catch (IJSOCK_Exception *E)
+    {
+        outputExceptionEx(*E);
+        E->Release();
+    }
+    catch (IException *E)
+    {
+        if (!isSoapRpcException(E))
+            throw E;
+        outputExceptionEx(*E);
+        E->Release();
+    }
+
+    fputs("Still polling...\n", stderr);
+    return WUStateUnknown; //socket issue, keep polling
+}
+
+
+WUState EclCmdWithEclTarget::pollForCompile(IClientWsWorkunits* client, const char *wuid, unsigned startTimeMs)
+{
+    try
+    {
+        Owned<IClientWUWaitRequest> req = client->createWUWaitCompiledRequest();
+        req->setWuid(wuid);
+        req->setWait(0);
+        req->setReturnOnWait(false);
+
+        if (optVerbose)
+            fputs("Polling for compile...\n", stdout);
+        WUState state = WUStateUnknown;
+        for(;;)
+        {
+            state = checkCompiled(client, req);
+            if (state != WUStateUnknown)
+                break;
+            unsigned waited = msTick() - startTimeMs;
+            if (optWaitTime!=(unsigned)-1 && waited>=optWaitTime)
+                return WUStateUnknown;
+            Sleep(nextWait(optWaitTime, waited));
+        }
+
+        switch (state)
+        {
+        case WUStateCompiled:
+        case WUStateCompleted:
+            return state;
+        case WUStateFailed:
+        case WUStateAborted:
+            fprintf(stderr, "%s %s.\n", wuid, getWorkunitStateStr(state));
+            break;
+        default:
+            fprintf(stderr, "%s in unrecognized state.\n", wuid);
+            break;
+        }
+        return state;
+    }
+    catch (IMultiException *ME)
+    {
+        outputMultiExceptionsEx(*ME);
+        ME->Release();
+    }
+    catch (IException *E)
+    {
+        StringBuffer msg;
+        fprintf(stderr, "Exception polling for compile: %d: %s\n", E->errorCode(), E->errorMessage(msg).str());
+        E->Release();
+    }
+    return WUStateUnknown;
+}
+
+
+bool EclCmdWithEclTarget::doDeploy(IClientWsWorkunits *client, unsigned waitMs, const char *cluster, const char *name, StringBuffer *wuid, StringBuffer *wucluster, bool noarchive, bool displayWuid, bool compress, bool protect)
 {
     int major = 0;
     int minor = 0;
     int point = 0;
     bool useCompression = false;
-    checkFeatures(cmd, client, useCompression, major, minor, point, 0, cmd.optWaitConnectMs, cmd.optWaitReadSec);
+    checkFeatures(client, useCompression, major, minor, point, 0, optWaitConnectMs, optWaitReadSec);
 
     bool compressed = false;
     if (useCompression)
     {
         MemoryBuffer mb;
-        fastLZCompressToBuffer(mb, cmd.optObj.mb.length(), cmd.optObj.mb.bufferBase());
-        cmd.optObj.mb.swapWith(mb);
+        fastLZCompressToBuffer(mb, optObj.mb.length(), optObj.mb.bufferBase());
+        optObj.mb.swapWith(mb);
         compressed=true;
     }
 
     StringBuffer s;
-    if (cmd.optVerbose)
-        fprintf(stdout, "\nDeploying %s\n", cmd.optObj.getDescription(s).str());
+    if (optVerbose)
+        fprintf(stdout, "\nDeploying %s\n", optObj.getDescription(s).str());
 
     StringBuffer objType(compressed ? "compressed_" : ""); //change compressed type string so old ESPs will fail gracefully
     Owned<IClientWUDeployWorkunitRequest> req = client->createWUDeployWorkunitRequest();
-    cmd.setRpcOptions(req->rpc(), waitMs);
+    setRpcOptions(req->rpc(), waitMs);
 
-    switch (cmd.optObj.type)
+    switch (optObj.type)
     {
         case eclObjArchive:
             req->setObjType(objType.append("archive"));
@@ -133,7 +291,7 @@ bool doDeploy(EclCmdWithEclTarget &cmd, IClientWsWorkunits *client, unsigned wai
             break;
         }
         default:
-            fprintf(stderr, "Cannot deploy %s\n", cmd.optObj.queryTypeName());
+            fprintf(stderr, "Cannot deploy %s\n", optObj.queryTypeName());
             return false;
     }
 
@@ -141,30 +299,33 @@ bool doDeploy(EclCmdWithEclTarget &cmd, IClientWsWorkunits *client, unsigned wai
         req->setName(name);
     if (cluster && *cluster)
         req->setCluster(cluster);
-    req->setObject(cmd.optObj.mb);
-    req->setFileName(cmd.optObj.value.str());
-    if ((int)cmd.optResultLimit > 0)
-        req->setResultLimit(cmd.optResultLimit);
-    if (cmd.getFullAttributePath(s.clear()))
+    req->setObject(optObj.mb);
+    req->setFileName(optObj.value.str());
+    if ((int)optResultLimit > 0)
+        req->setResultLimit(optResultLimit);
+    if (getFullAttributePath(s.clear()))
         req->setQueryMainDefinition(s);
-    if (!cmd.optDefaultRepo.isEmpty())
-        addNamedValue("eclcc--defaultrepo", cmd.optDefaultRepo, cmd.debugValues);
-    if (!cmd.optDefaultRepoVersion.isEmpty())
-        addNamedValue("eclcc--defaultrepoversion", cmd.optDefaultRepoVersion, cmd.debugValues);
+    if (!optDefaultRepo.isEmpty())
+        addNamedValue("eclcc--defaultrepo", optDefaultRepo, debugValues);
+    if (!optDefaultRepoVersion.isEmpty())
+        addNamedValue("eclcc--defaultrepoversion", optDefaultRepoVersion, debugValues);
 
-    if (cmd.optLegacy)
-        addNamedValue("eclcc-legacy", "true", cmd.debugValues);
-    if (cmd.optSnapshot.length())
-        req->setSnapshot(cmd.optSnapshot);
-    expandDefintionsAsDebugValues(cmd.definitions, cmd.debugValues);
-    if (cmd.debugValues.length())
+    if (optLegacy)
+        addNamedValue("eclcc-legacy", "true", debugValues);
+    if (optSnapshot.length())
+        req->setSnapshot(optSnapshot);
+    expandDefintionsAsDebugValues(definitions, debugValues);
+    if (debugValues.length())
     {
-        req->setDebugValues(cmd.debugValues);
-        cmd.debugValues.kill();
+        req->setDebugValues(debugValues);
+        debugValues.kill();
     }
     if (protect)
         req->setProtect(true);
 
+    req->setWait(getInitialRunWait());
+
+    unsigned startTimeMs = msTick();
     Owned<IClientWUDeployWorkunitResponse> resp;
     try
     {
@@ -176,7 +337,7 @@ bool doDeploy(EclCmdWithEclTarget &cmd, IClientWsWorkunits *client, unsigned wai
         E->errorMessage(msg);
         int code = E->errorCode();
 
-        if (cmd.optVerbose)
+        if (optVerbose)
             fprintf(stdout, "Deploy workunit failed with exception %u:%s\n", code, msg.str());
 
         //ESP doesn't want to process requests that are too large, and so disconnects before reading
@@ -185,11 +346,11 @@ bool doDeploy(EclCmdWithEclTarget &cmd, IClientWsWorkunits *client, unsigned wai
             throw;
         if (useCompression) //newer build, not a maxRequestEntityLength issue
             throw;
-        size32_t maxEntity = getMaxRequestEntityLength(cmd); //only do the work to grab max buffersize if we've failed
+        size32_t maxEntity = getMaxRequestEntityLength(*this); //only do the work to grab max buffersize if we've failed
         if (maxEntity > 1000)
         {
             size32_t maxBufferSize = ((maxEntity - 999) / 4) * 3; //account for soap, other parameters, and base64 encoding (n / 4 * 3)
-            if (maxBufferSize && cmd.optObj.mb.length() > maxBufferSize)
+            if (maxBufferSize && optObj.mb.length() > maxBufferSize)
             {
                 fprintf(stderr, "\nError: %s is larger than maxRequestEntityLength configured for ESP allows.\n", objType.str());
                 E->Release();
@@ -205,21 +366,26 @@ bool doDeploy(EclCmdWithEclTarget &cmd, IClientWsWorkunits *client, unsigned wai
     {
         if (wuid)
             wuid->clear().append(w);
+
+        IConstECLWorkunit & workunit = resp->getWorkunit();
+        WUState state = getWorkUnitState(workunit.getState());
+        if (optPoll && !isFinalCompileState(state))
+            state = pollForCompile(client, w, startTimeMs);
+
         if (wucluster)
-            wucluster->clear().append(resp->getWorkunit().getCluster());
+            wucluster->clear().append(workunit.getCluster());
         fprintf(stdout, "\n");
-        if (cmd.optVerbose)
+        if (optVerbose)
             fprintf(stdout, "Deployed\n   wuid: ");
-        const char *state = resp->getWorkunit().getState();
-        bool isCompiled = (strieq(state, "compiled")||strieq(state, "completed"));
-        if (displayWuid || cmd.optVerbose || !isCompiled)
+        bool isCompiled = ::isCompiled(state);
+        if (displayWuid || optVerbose || !isCompiled)
             fprintf(stdout, "%s\n", w);
-        if (cmd.optVerbose || !isCompiled)
-            fprintf(stdout, "   state: %s\n\n", state);
+        if (optVerbose || !isCompiled)
+            fprintf(stdout, "   state: %s\n\n", getWorkunitStateStr(state));
 
         unsigned errorCount=0;
         unsigned warningCount=0;
-        IArrayOf<IConstECLException> &exceptions = resp->getWorkunit().getExceptions();
+        IArrayOf<IConstECLException> &exceptions = workunit.getExceptions();
         ForEachItemIn(i, exceptions)
         {
             IConstECLException &e = exceptions.item(i);
@@ -242,7 +408,7 @@ bool doDeploy(EclCmdWithEclTarget &cmd, IClientWsWorkunits *client, unsigned wai
         return isCompiled;
     }
 
-    if (cmd.optVerbose)
+    if (optVerbose)
         fprintf(stdout, "Deploy failed\n");
     return false;
 }
@@ -289,7 +455,7 @@ class EclCmdDeploy : public EclCmdWithEclTarget
     virtual int processCMD()
     {
         Owned<IClientWsWorkunits> client = createCmdClientExt(WsWorkunits, *this, "?upload_"); //upload_ disables maxRequestEntityLength
-        return doDeploy(*this, client, 0, optTargetCluster.get(), optName.get(), NULL, NULL, optNoArchive, true, true, optProtect) ? 0 : 1;
+        return doDeploy(client, 0, optTargetCluster.get(), optName.get(), NULL, NULL, optNoArchive, true, true, optProtect) ? 0 : 1;
     }
     virtual void usage()
     {
@@ -447,7 +613,7 @@ class EclCmdPublish : public EclCmdWithEclTarget
         StringBuffer wuid;
         if (optObj.type==eclObjWuid)
             wuid.set(optObj.value.get());
-        else if (!doDeploy(*this, client, optMsToWait, optTargetCluster.get(), optJobName.length() ? optJobName.get() : optQueryName.get(), &wuid, NULL, optNoArchive, true, true, optProtect))
+        else if (!doDeploy(client, optMsToWait, optTargetCluster.get(), optJobName.length() ? optJobName.get() : optQueryName.get(), &wuid, NULL, optNoArchive, true, true, optProtect))
             return 1;
 
         unsigned remaining = 0;
@@ -602,23 +768,10 @@ class EclCmdPublish : public EclCmdWithEclTarget
     bool optDontAppendCluster; //Undesirable but here temporarily because DALI may have locking issues
 };
 
-inline unsigned nextWait(unsigned wait, unsigned waited)
-{
-    if (waited < 5000)
-        return 1000;
-    if (waited < 30000)
-        return 5000;
-    if (waited < 60000)
-        return 10000;
-    if (waited < 120000)
-        return 30000;
-    return 60000;
-}
-
 class EclCmdRun : public EclCmdWithEclTarget
 {
 public:
-    EclCmdRun() : optExceptionSeverity("info"), optWaitTime((unsigned)-1), optNoRoot(false)
+    EclCmdRun() : optExceptionSeverity("info"), optNoRoot(false)
     {
         optObj.accept = eclObjWuid | eclObjArchive | eclObjSharedObject | eclObjWuid | eclObjQuery;
     }
@@ -638,12 +791,8 @@ class EclCmdRun : public EclCmdWithEclTarget
                 continue;
             if (iter.matchOption(optInput, ECLOPT_INPUT)||iter.matchOption(optInput, ECLOPT_INPUT_S))
                 continue;
-            if (iter.matchOption(optWaitTime, ECLOPT_WAIT))
-                continue;
             if (iter.matchFlag(optNoRoot, ECLOPT_NOROOT))
                 continue;
-            if (iter.matchFlag(optPoll, ECLOPT_POLL))
-                continue;
             if (iter.matchFlag(optPre64, "--pre64")) //only for troubleshooting, do not document
                 continue;
             if (iter.matchFlag(optProtect, ECLOPT_PROTECT))
@@ -674,45 +823,7 @@ class EclCmdRun : public EclCmdWithEclTarget
         return true;
     }
 
-    inline bool isSoapRpcException(IException *E)
-    {
-        StringBuffer msg;
-        const char *finger = E->errorMessage(msg).str();
-        if (strncmp(finger, "SOAP ", 5))
-            return false;
-        finger+=5;
-        if (!strncmp(finger, "rpc error", 9))
-            return true;
-        if (!strncmp(finger, "Connection error", 16))
-            return true;
-        return false;
-    }
-    int checkComplete(IClientWsWorkunits* client, IClientWUWaitRequest* req)
-    {
-        try
-        {
-            Owned<IClientWUWaitResponse> resp = client->WUWaitComplete(req);
-            if (resp->getExceptions().ordinality())
-                throw LINK(&resp->getExceptions());
-            return resp->getStateID();
-        }
-        catch (IJSOCK_Exception *E)
-        {
-            outputExceptionEx(*E);
-            E->Release();
-        }
-        catch (IException *E)
-        {
-            if (!isSoapRpcException(E))
-                throw E;
-            outputExceptionEx(*E);
-            E->Release();
-        }
-
-        fputs("Still polling...\n", stderr);
-        return WUStateUnknown; //socket issue, keep polling
-    }
-
+    using EclCmdWithEclTarget::checkComplete;
     int checkComplete(IClientWsWorkunits* client, IClientWUInfoRequest* req)
     {
         try
@@ -890,7 +1001,7 @@ class EclCmdRun : public EclCmdWithEclTarget
         int minor = 0;
         int point = 0;
         bool useCompression = false;
-        checkFeatures(*this, client, useCompression, major, minor, point, optWaitTime, optWaitConnectMs, optWaitReadSec);
+        checkFeatures(client, useCompression, major, minor, point, optWaitTime, optWaitConnectMs, optWaitReadSec);
         bool optimized = !optPre64 && ((major>=7) || (major==6 && minor>=3));
 
         try
@@ -926,27 +1037,6 @@ class EclCmdRun : public EclCmdWithEclTarget
         }
         return 1;
     }
-    int getInitialRunWait()
-    {
-        if (!optPoll)
-            return optWaitTime;
-        return (optWaitTime < 10000) ? optWaitTime : 10000; //stay connected for the first 10 seconds even if polling
-    }
-    bool isFinalState(WUState state)
-    {
-        switch (state)
-        {
-        case WUStateUnknown:
-        case WUStateArchived:
-        case WUStateAborting:
-        case WUStateCompleted:
-        case WUStateFailed:
-        case WUStateAborted:
-            return true;
-        }
-        return false;
-    }
-
     virtual int processCMD()
     {
         Owned<IClientWsWorkunits> client = createCmdClientExt(WsWorkunits, *this, "?upload_"); //upload_ disables maxRequestEntityLength
@@ -983,7 +1073,7 @@ class EclCmdRun : public EclCmdWithEclTarget
         else
         {
             req->setCloneWorkunit(false);
-            if (!doDeploy(*this, client, optWaitTime, optTargetCluster.get(), optName.get(), &wuid, &wuCluster, optNoArchive, optVerbose, true, optProtect))
+            if (!doDeploy(client, optWaitTime, optTargetCluster.get(), optName.get(), &wuid, &wuCluster, optNoArchive, optVerbose, true, optProtect))
                 return 1;
             req->setWuid(wuid.str());
             if (optVerbose)
@@ -1040,7 +1130,7 @@ class EclCmdRun : public EclCmdWithEclTarget
         if (optVerbose && respwuid.length() && !streq(wuid.str(), respwuid.str()))
             fprintf(stdout, "As %s\n", respwuid.str());
         WUState state = getWorkUnitState(resp->getState());
-        if (optPoll && !isFinalState(state))
+        if (optPoll && !isFinalRunState(state))
             return pollForResults(client, respwuid);
 
         switch (state)
@@ -1102,8 +1192,6 @@ class EclCmdRun : public EclCmdWithEclTarget
             "   --job-name=<val>          job name\n"
             "   -in,--input=<file|xml>    file or xml content to use as query input\n"
             "   -X<name>=<value>          sets the stored input value (stored('name'))\n"
-            "   --wait=<ms>               time to wait for completion\n"
-            "   --poll                    poll for results, rather than remain connected\n"
             "   --exception-level=<level> minimum severity level for exceptions\n"
             "                             values: 'info', 'warning', 'error'\n"
             "   --protect                 protect workunit from deletion\n",
@@ -1115,10 +1203,8 @@ class EclCmdRun : public EclCmdWithEclTarget
     StringAttr optInput;
     StringAttr optExceptionSeverity;
     IArrayOf<IEspNamedValue> variables;
-    unsigned optWaitTime = 0;
     unsigned startTimeMs = 0;
     bool optNoRoot = false;
-    bool optPoll = false;
     bool optPre64 = false;  //only for troubleshooting, do not document
     bool optProtect = false;
 };
@@ -1252,7 +1338,7 @@ class EclCmdResults : public EclCmdCommon
         int minor = 0;
         int point = 0;
         bool useCompression = false;
-        checkFeatures(*this, client, useCompression, major, minor, point, 0, optWaitConnectMs, optWaitReadSec);
+        checkFeatures(client, useCompression, major, minor, point, 0, optWaitConnectMs, optWaitReadSec);
 
         if (!optPre64 && (major>=6 && minor>=3))
             return getAndOutputResults(client, optWuid);
diff --git a/esp/services/ws_sql/ws_sqlService.cpp b/esp/services/ws_sql/ws_sqlService.cpp
index f339e0ad720..a6204cf75fe 100644
--- a/esp/services/ws_sql/ws_sqlService.cpp
+++ b/esp/services/ws_sql/ws_sqlService.cpp
@@ -1545,7 +1545,8 @@ bool CwssqlEx::onPrepareSQL(IEspContext &context, IEspPrepareSQLRequest &req, IE
                 wu.clear();
 
                 WsWuHelpers::submitWsWorkunit(context, wuid.str(), cluster, nullptr, 0, 0, true, false, false, xmlparams.str(), nullptr, nullptr, nullptr);
-                success = waitForWorkUnitToCompile(wuid.str(), req.getWait());
+                WUState state = waitForWorkUnitToCompile(wuid.str(), req.getWait());
+                success = isCompiled(state);
             }
 
            if (success)
diff --git a/esp/services/ws_workunits/ws_workunitsService.cpp b/esp/services/ws_workunits/ws_workunitsService.cpp
index 509ae96216a..c83707a6598 100644
--- a/esp/services/ws_workunits/ws_workunitsService.cpp
+++ b/esp/services/ws_workunits/ws_workunitsService.cpp
@@ -1184,12 +1184,7 @@ bool CWsWorkunitsEx::onWUWaitCompiled(IEspContext &context, IEspWUWaitRequest &r
         ensureWsWorkunitAccess(context, wuid.str(), SecAccess_Full);
         PROGLOG("WUWaitCompiled: %s", wuid.str());
 
-        secWaitForWorkUnitToCompile(wuid.str(), context.querySecManager(), context.queryUser(), req.getWait());
-        Owned<IWorkUnitFactory> factory = getWorkUnitFactory(context.querySecManager(), context.queryUser());
-        Owned<IConstWorkUnit> cw = factory->openWorkUnit(wuid.str());
-        if(!cw)
-            throw MakeStringException(ECLWATCH_CANNOT_OPEN_WORKUNIT,"Cannot open workunit %s.",wuid.str());
-        resp.setStateID(cw->getState());
+        resp.setStateID(secWaitForWorkUnitToCompile(wuid.str(), context.querySecManager(), context.queryUser(), req.getWait()));
     }
     catch(IException* e)
     {