 				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


					dispatch_group_enter(group)
					rawTask.terminationHandler = { nstask in
						let terminationStatus = nstask.terminationStatus
						if terminationStatus == EXIT_SUCCESS {
							// Wait for stderr to finish, then pass
							// through stdout.
							disposable += stderrAggregated
								.then(stdoutAggregated)
								.map(TaskEvent.Success)
								.start(observer)
						} else {
							// Wait for stdout to finish, then pass
							// through stderr.
							disposable += stdoutAggregated
								.then(stderrAggregated)
								.flatMap(.Concat) { data -> SignalProducer<TaskEvent<NSData>, TaskError> in
									let errorString = (data.length > 0 ? NSString(data: data, encoding: NSUTF8StringEncoding) as? String : nil)
									return SignalProducer(error: .ShellTaskFailed(task, exitCode: terminationStatus, standardError: errorString))

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

					stderrProducer.startWithSignal { signal, signalDisposable in
