Struct LiveOutputObserver 

pub struct LiveOutputObserver<O, E>
where
    O: Write + Send,
    E: Write + Send,
{ /* private fields */ }

Live-mode RunObserver per EXEC-016.

See the module-level docs for the presentation contract. Constructed with two sinks via Self::new; the inner sinks can be reclaimed with Self::into_inner after the run completes.

Errors

Sink writes go through Write::write_all. The trait method signatures on RunObserver do NOT return errors; a write failure in the sink is therefore silently ignored at this layer. Production callers wire stdout and stderr to the parent process’s terminal streams, where write failure is a terminal-condition concern out of scope here. Tests use Vec<u8> sinks, which cannot fail.

Implementations

impl<O, E> LiveOutputObserver<O, E>

where O: Write + Send, E: Write + Send,

pub fn new(stdout: O, stderr: E) -> Self

Build an observer that writes complete lines to stdout and stderr with per-task tag prefixes from PlainPresenter (the historical [project:task] format, no per-task summary lines). Equivalent to Self::with_presenter called with Arc::new(PlainPresenter).

pub fn with_presenter( stdout: O, stderr: E, presenter: Arc<dyn TaskPresenter>, ) -> Self

Build an observer that delegates prefix and summary-line rendering to presenter.

Callers that want color, glyph status markers, or per-task duration summaries inject a colour-aware presenter; library tests use the default PlainPresenter via Self::new.

pub fn into_inner(self) -> (O, E)

Reclaim the two sinks after the run has finished and the observer is no longer borrowed by the scheduler. The returned tuple is (stdout, stderr).

Trait Implementations

impl<O, E> RunObserver for LiveOutputObserver<O, E>

where O: Write + Send, E: Write + Send,

fn on_task_started(&self, task: &TaskId)

Called once at the start of the run, before any cache work.

fn on_stdout(&self, task: &TaskId, bytes: &[u8])

One chunk of captured stdout bytes. For a cache hit, called exactly once with the recorded stdout in full. For a fresh run, the call shape depends on the observer’s presentation strategy: a buffered observer typically receives a single call with the whole captured stdout; a live observer may receive many sub-line chunks as bytes flow from the pipe.

fn on_stderr(&self, task: &TaskId, bytes: &[u8])

One chunk of captured stderr bytes. Same call shape as Self::on_stdout.

fn on_task_finished(&self, task: &TaskId, record: &CompletedRecord)

Called once at the end of the run with the run-record classification. Fires only for tasks the scheduler admitted into the lookup-then-spawn pipeline; cascade- skipped tasks surface through Self::on_task_skipped instead.

fn on_task_skipped(&self, task: &TaskId, record: &SkipRecord)

Called once at the moment the scheduler marks task cascade-skipped per EXEC-010 / EXEC-011. Fires before the next admission round; NEVER paired with Self::on_task_started or Self::on_task_finished for the same task.

fn on_task_cancelled(&self, task: &TaskId, record: &CancelledRecord)

Called once at the moment the cancellation flow records a terminal state for task per EXEC-012..015. The CancelledRecord variant distinguishes the three shapes: an in-flight task that was signalled by the executor; a cascade descendant of a cancelled task; or a task drained from state.ready on cancel-fire. For an in-flight task, Self::on_task_started has already fired and Self::on_task_finished does NOT fire; for the other two shapes, no other lifecycle callback fires for the same task.