     resourcePath = process.cwd()
     appPath = getAppPath()
 
-    # Ensure application is executable on Linux
-    fs.chmodSync(appPath, '755') if process.platform is 'linux'
-
     packageSpecQueue = async.queue (packagePath, callback) ->
-      if process.platform in ['darwin', 'linux']
-        options =
-          cmd: appPath
-          args: ['--test', "--resource-path=#{resourcePath}", path.join(packagePath, 'spec')]
-          opts:
-            cwd: packagePath
-            env: _.extend({}, process.env, ATOM_PATH: rootDir)
-      else if process.platform is 'win32'
-        options =
-          cmd: process.env.comspec
-          args: ['/c', appPath, '--test', "--resource-path=#{resourcePath}", "--log-file=ci.log", path.join(packagePath, 'spec')]
-          opts:
-            cwd: packagePath
-            env: _.extend({}, process.env, ATOM_PATH: rootDir)
+      options =
+        cmd: appPath
+        args: ['--test', "--resource-path=#{resourcePath}", path.join(packagePath, 'spec')]
+        opts:
+          cwd: packagePath
+          env: _.extend({}, process.env, ELECTRON_ENABLE_LOGGING: true, ATOM_PATH: rootDir)
 
       grunt.log.ok "Launching #{path.basename(packagePath)} specs."
-      spawn options, (error, results, code) ->
-        if process.platform is 'win32'
-          if error
-            process.stderr.write(fs.readFileSync(path.join(packagePath, 'ci.log')))
-          fs.unlinkSync(path.join(packagePath, 'ci.log'))
-
+      spawn options, (error) ->
         failedPackages.push path.basename(packagePath) if error
-        logDeprecations("#{path.basename(packagePath)} Specs", results)
         callback()
 
     modulesDirectory = path.resolve('node_modules')

        [coreSpecFailed, failedPackages] = results

      elapsedTime = Math.round((Date.now() - startTime) / 100) / 10
      grunt.log.ok("Total spec time: #{elapsedTime}s using #{concurrency} cores")
      failures = failedPackages
      failures.push "atom core" if coreSpecFailed

      grunt.log.error("[Error]".red + " #{failures.join(', ')} spec(s) failed") if failures.length > 0

      if process.platform is 'win32' and process.env.JANKY_SHA1
        done()
      else
        done(not coreSpecFailed and failedPackages.length is 0)

      continue unless isAtomPackage(packagePath)
      packageSpecQueue.push(packagePath)

    packageSpecQueue.concurrency = 1
    packageSpecQueue.drain = -> callback(null, failedPackages)

  runCoreSpecs = (callback) ->
    appPath = getAppPath()
    resourcePath = process.cwd()
    coreSpecsPath = path.resolve('spec')

    options =
      cmd: appPath
      args: ['--test', "--resource-path=#{resourcePath}", coreSpecsPath, "--user-data-dir=#{temp.mkdirSync('atom-user-data-dir')}"]
      opts:
        env: _.extend({}, process.env, {ATOM_INTEGRATION_TESTS_ENABLED: true, ELECTRON_ENABLE_LOGGING: true})
        stdio: 'inherit'

    grunt.log.ok "Launching core specs."
    spawn options, (error, results) ->
      callback(null, error)

  grunt.registerTask 'run-specs', 'Run the specs', ->
    done = @async()
    startTime = Date.now()

    specs =
      if process.env.ATOM_SPECS_TASK is 'packages'
        [runPackageSpecs]
      else if process.env.ATOM_SPECS_TASK is 'core'
        [runCoreSpecs]
      else
        [runCoreSpecs, runPackageSpecs]

    async.series specs, (error, results) ->
      failedPackages = []
      coreSpecFailed = null

