 				let stdoutProducer = stdoutPipe.transferReadsToProducer()
 				let stderrProducer = stderrPipe.transferReadsToProducer()
 
+				enum Aggregation {
+					case Value(NSData)
+					case Failed(TaskError)
+					case Interrupted
+
+					var producer: SignalProducer<NSData, TaskError> {
+						switch self {
+						case let .Value(data):
+							return .init(value: data)
+						case let .Failed(error):
+							return .init(error: error)
+						case .Interrupted:
+							return SignalProducer { observer, _ in
+								observer.sendInterrupted()
+							}
+						}
+					}
+				}
+
 				return SignalProducer { observer, disposable in
-					let (stdoutAggregated, stdoutAggregatedObserver) = SignalProducer<NSData, TaskError>.buffer(1)
-					let (stderrAggregated, stderrAggregatedObserver) = SignalProducer<NSData, TaskError>.buffer(1)
+					let stdoutAggregated = MutableProperty<Aggregation?>(nil)
+					let stderrAggregated = MutableProperty<Aggregation?>(nil)
 
 					stdoutProducer.startWithSignal { signal, signalDisposable in
 						disposable += signalDisposable

							aggregate.appendData(data)
						}, failed: { error in
							observer.sendFailed(error)
							stdoutAggregatedObserver.sendFailed(error)
						}, completed: {
							stdoutAggregatedObserver.sendNext(aggregate)
							stdoutAggregatedObserver.sendCompleted()
						}, interrupted: stdoutAggregatedObserver.sendInterrupted
						))
					}

					stderrProducer.startWithSignal { signal, signalDisposable in

							aggregate.appendData(data)
						}, failed: { error in
							observer.sendFailed(error)
							stderrAggregated.value = .Failed(error)
						}, completed: {
							stderrAggregated.value = .Value(aggregate)
						}, interrupted: {
							stderrAggregated.value = .Interrupted
						}))
					}

					rawTask.standardOutput = stdoutPipe.writeHandle
