Pipeline execution flow

A Loom pipeline schedules and runs eligible jobs inside a local run. Runtime phase boundaries record when the pipeline starts and finishes, while each job's result determines whether later work can proceed.

Use this page when you want to answer:

• When does the pipeline actually begin?
• What job work can happen inside it?
• What causes downstream work to stop?

The current pipeline envelope

The pipeline itself is the pipeline.execute phase. Loom also wraps it in run-scoped phases:

Phase	Scope	What it means
run.bootstrap	Run	Loom captured run context and workspace attribution
run.pipeline_execute	Run	Outer envelope around pipeline work
pipeline.execute	Pipeline	The actual pipeline body
run.finalize	Run	Loom writes final contract artifacts after pipeline completion

What happens inside pipeline.execute

Inside the pipeline boundary, Loom repeatedly:

1. Selects work that is now eligible
2. Runs those jobs
3. Re-evaluates whether more work can proceed

Each runnable job then emits its own job-level phases, covered in Job execution flow.

What controls whether work can start

Loom uses these inputs to decide whether a job can start:

Control	What to rely on
Stage barriers	Omitted needs waits for all executable jobs in every earlier declared stage
Explicit dependencies	An explicit needs list replaces stage barriers; needs: [] adds no stage dependency
Artifact inputs	Artifact producers remain prerequisites independently of explicit or omitted needs
Upstream result	A failed prerequisite blocks its dependents; independent ready jobs continue

What a job failure does

When a job fails:

• The failed job closes with status: "failed"
• Jobs that already finished keep their existing result
• Jobs that require the failed job become blocked
• Dependency-independent jobs continue when they are ready
• The pipeline still emits a clean pipeline.execute finish boundary

The finish boundary records the pipeline result, and the manifests point to the failed job.

How this shows up in runtime artifacts

Artifact	What you see
pipeline/events.jsonl	phase_start and phase_finish for pipeline.execute
pipeline/summary.json	Final pipeline status, exit_code, duration_ms, and optional error
pipeline/manifest.json	Job roster plus failing_job_id and failing_job_manifest_path on failure
phase-report.json	Whether required run and pipeline boundaries were emitted in the right order

Current behavior to rely on

Design and troubleshooting guidance for the current runtime:

• The pipeline is represented by one pipeline.execute boundary per run.
• Job work happens inside that boundary, not before or after it.
• A failed job blocks its dependents while independent ready jobs continue; Loom still closes the pipeline phase as failed.
• run.finalize happens after pipeline.execute completes and is where final contract artifacts are written.

If you need the per-job phase order inside that pipeline, continue to Job execution flow.