 						}
 					}
 			}
+			|> observeOn(scheduler)
 			|> startWithSignal { signal, taskDisposable in
 				disposable.addDisposable(taskDisposable)
 				signal.observe(observer)

				disposable.addDisposable(producerDisposable)

				signal.observe(next: { data in
					let dispatchData = dispatch_data_create(data.bytes, data.length, queue, nil)

					dispatch_io_write(channel, 0, dispatchData, queue) { (done, data, error) in
						if error != 0 {
							sendError(observer, .POSIXError(error))
						}

		var stdinProducer: SignalProducer<(), ReactiveTaskError> = .empty

		if let input = taskDescription.standardInput {
			switch Pipe.create(queue) {
			case let .Success(pipe):
				task.standardInput = pipe.value.readHandle

				stdinProducer = pipe.value.writeDataFromProducer(input) |> on(started: {
					close(pipe.value.readFD)
				})

			case let .Failure(error):
				sendError(observer, error.value)
			}
		}

		SignalProducer(result: Pipe.create(queue))
			|> zipWith(SignalProducer(result: Pipe.create(queue)))
			|> flatMap(.Merge) { stdoutPipe, stderrPipe -> SignalProducer<NSData, ReactiveTaskError> in
				let stdoutProducer = aggregateDataReadFromPipe(stdoutPipe, standardOutput, scheduler)
				let stderrProducer = aggregateDataReadFromPipe(stderrPipe, standardError, scheduler)

				let terminationStatusProducer = SignalProducer<Int32, NoError> { observer, disposable in
					task.terminationHandler = { task in
