     
     public func resume() -> Bool
     {
-        // always try `_performInitClosure` only once on `resume()`
-        // even when to-Resume-transition fails, e.g. already been fulfilled/rejected
-        self._performInitClosure?()
-        self._performInitClosure = nil
+        //
+        // Always try `_performInitClosure` only once on `resume()`
+        // even when `.Pause => .Resume` transition fails, e.g. already been fulfilled/rejected.
+        //
+        // NOTE:
+        // **`downstream._performInitClosure` should be invoked first before `downstream.machine <-! .Resume`**
+        // to add upstream's progress/fulfill/reject handlers inside `downstream.initClosure()` 
+        // before their actual calls, which often happens 
+        // when downstream's `resume()` is configured to call upstream's `resume()`
+        // which eventually calls `upstream._performInitClosure` and thus actual event handlers.
+        //
+        if (self._performInitClosure != nil) {
+            
+            let isPaused = self.machine.state == .Paused
+            
+            //
+            // Temporarily switch to `.Running` without invoking `configure.resume()`.
+            // This allows paused-inited-task to safely call progress/fulfill/reject handlers
+            // inside its `initClosure` *immediately*.
+            //
+            if isPaused {
+                self.machine <-! ._InitResume
+            }
+            
+            self._performInitClosure?()
+            self._performInitClosure = nil
+            
+            if isPaused {
+                self.machine <-! ._InitPause    // switch back
+            }
+        }
         
         return self.machine <-! .Resume
     }

    internal typealias _RejectHandler = (ErrorInfo) -> Void
    internal typealias _InitClosure = (machine: Machine, progress: ProgressHandler, fulfill: FulFillHandler, _reject: _RejectHandler, configure: TaskConfiguration) -> Void
    
    internal typealias Machine = StateMachine<TaskState, TaskEvent>
    
    private var machine: Machine!
    

        
        // setup state machine
        self.machine = Machine(state: initialState) {
            
            $0.addRouteEvent(._InitPause, transitions: [.Running => .Paused])
            $0.addRouteEvent(._InitResume, transitions: [.Paused => .Running])
            
            $0.addRouteEvent(.Pause, transitions: [.Running => .Paused])
            $0.addRouteEvent(.Resume, transitions: [.Paused => .Running])
