       # If other language than nodejs, run hooks worker client
       # Worker client will start the worker server and pass the "hookfiles" options as CLI arguments to it
       else
-        # start hooks worker
+        # Start hooks worker
         hooksWorkerClient = new HooksWorkerClient(runner)
         hooksWorkerClient.start callback
 
     # Loading files in sandboxed mode
     else
 
-      # load sandbox files from fs
+      # Load sandbox files from fs
       logger.info('Loading hook files in sandboxed context:', files)
-      async.eachSeries files, (fileName, nextFile) ->
-        resolvedPath = path.resolve((customConfigCwd or process.cwd()), fileName)
-        # load hook file content
+      async.eachSeries files, (resolvedPath, nextFile) ->
+        # Load hook file content
         fs.readFile resolvedPath, 'utf8', (readingError, data) ->
           return nextFile(readingError) if readingError
-          # run code in sandbox
+          # Run code in sandbox
           sandboxHooksCode data, (sandboxError, result) ->
             return nextFile(sandboxError) if sandboxError
             runner.hooks = mergeSandboxedHooks(runner.hooks, result)

        callback(new Error(msg))
    else

      # no data found, doing nothing
      return callback()

  # Loading hookfiles from fs
  else

    # Clone the configuration object to hooks.configuration to make it
    # accessible in the node.js hooks API
    runner.hooks.configuration = clone runner?.configuration

    # Expand globs
    files = []
    globs = [].concat runner?.configuration?.options?.hookfiles
    for globItem in globs
      files = files.concat glob.sync(globItem)

    logger.info('Found Hookfiles:', files)

    # Loading files in non sandboxed nodejs
    if not runner.configuration.options.sandbox == true

    if typeof(runner.configuration.hooksData) != 'object' or Array.isArray(runner.configuration.hooksData) != false
      return callback(new Error("hooksData option must be an object e.g. {'filename.js':'console.log(\"Hey!\")'}"))

    # Run code in sandbox
    async.eachSeries Object.keys(runner.configuration.hooksData), (key, nextHook) ->
      data = runner.configuration.hooksData[key]

      # Run code in sandbox
      sandboxHooksCode data, (sandboxError, result) ->
        return nextHook(sandboxError) if sandboxError

        # Merge stringified hooks
        runner.hooks = mergeSandboxedHooks(runner.hooks, result)

        # Fixing #168 issue
