---
name: "workflow-delivery-loop"
type: workflow
description: The delivery workflow — the standing path every build ticket flows through, from Backlog to Done, composing the Relay, Forge and Prism behaviours across the triage, build, review and merge stages with the operator as the gate. Read to see the whole delivery path at a glance, or to render the Layer 4 Workflows layer on the agents site. The executable inner loop is driven by routine-delivery-loop; this is the path that loop runs.
license: CC BY-NC-SA 4.0
---

# Delivery workflow

The worked example of a Layer 4 workflow: the standing process a build ticket flows through to reach Done. It composes behaviour from Layers 1–3 — Relay triages and merges, Forge builds, Prism reviews — with the operator as the gate. The workflow is the whole path; the loop (routine-delivery-loop) is the executable inner cycle that runs it on the Claude Code surface.

## The path

```mermaid
flowchart LR
  B[Backlog] --> T{Relay · triage}
  T -->|needs code| TD[Todo · F0-RGE]
  T -->|human-owned| HU[exec:human]
  TD --> F[Forge · build, open PR]
  F -->|blocker| BL[Blocked · operator]
  F --> IR[In Review · PR-1SM]
  IR --> QA{Prism · verdict}
  QA -->|changes needed| TD
  QA -->|clean + flagged| OP{Operator · gate}
  QA -->|clean + unflagged| MG[Relay · merge]
  OP -->|approve · R3-LAY| MG
  OP -->|bounce| TD
  MG --> DN[Done]
```

## Stages

Triage (Relay) → Build (Forge, never merges) → Review (Prism, never advances) → Merge (Relay, on the approval signal).

## Design review — UI surfaces only

A ticket whose deliverable is a **UI surface** — a page, a screen, a console, a dashboard, any rendered interface a person looks at — carries one further read inside the Review stage: the **rendered output** is read against a design bar, not only against its acceptance criteria. The step fires on the surface, not on the ticket. A schema change, a migration, a script, an API or a docs ticket does not take it, and a ticket with no rendered output is not slowed by it.

**Why it belongs to the workflow and not to a skill.** Prism's QA pass is criteria- and contract-shaped: it verifies that the build meets its spec, which leaves unasked whether the spec produced a good surface. Acceptance criteria written from a design review do not close that gap — they are the spec, and the spec is the thing under test. The question has a feeder already in `skill-design-parity`, which compares a built interface against its intended design and reports divergences in plain language, so the step **engages the existing pass rather than adding a behaviour**; where parity and QA run on one leg the verdicts fold into one comment per surface. `skill-design-review-round` is not the home: its scope is a design-tool comment round triaged with the Owner — an intake path from observations to work — not a build gate.

**The step names the bar it reads; it does not restate one.** Review criteria live inside the build ticket as two literal checkbox sections (`convention-ticket`, *Review criteria live inside the build ticket*), so a design review is a named gate in that ticket carrying its own criteria, in the same place as every other gate's. What those criteria point at depends on the surface:

- a venture surface — the venture's `convention-brand` instance and `standard-design-system`, with `convention-aesthetic` above both;
- a **metrics surface** — `standard-metrics-surface` is the bar for that case; read it there rather than restating any of it here;
- any surface — the rendered result at **both laptop and phone width**, since a surface that reads well at one and not the other has not been reviewed.

A design-review verdict routes exactly as a QA verdict does: divergences bounce the ticket to Todo on the same two-strike bounce path; a clean read leaves the gate where it was. It is a feeder into the one gate, never a second gate, and it does not advance or merge.

(Worked case: a dashboard rebuild ran this path end to end — built, checked against its acceptance criteria and the type contract, and merged — and reached the Owner, who rejected it on sight. Its acceptance criteria had themselves been written from a design review, and nothing read the rendered result before he did. That the review leg ruled the ticket clean and that the merge leg merged it are the filing note's **report**; no repo, pull request or ticket history is readable from the authoring surface. APP-2527.)

## Lanes

The executor axis carries the work: R3-LAY (triage / merge) → F0-RGE (build) → PR-1SM (review) → R3-LAY (merge gate). Status is the lock — Todo is ready, In Progress is running, In Review is awaiting review or approval.

## The gate

Unflagged, clean, unblocked work merges autonomously: the loop's clean-pass routing to R3-LAY is itself the approval signal (Option A, 2026-06-25). Flagged work, QA blocks, bounce-cap escalations and merge failures stop for the operator.

## Bounce path

A "changes needed" verdict bounces the ticket to Todo for Forge. The cap is two strikes — one auto-bounce, then escalate to the operator. The strike count is read from the Linear thread, not session state.

## Relationship to the routine

This workflow is the single source for the delivery process — its stages, gates, hand-offs and rules are stated here, and a scheduled artefact that runs it references them rather than restating them (Owner ruling, Aled, 2026-10-23, APP-2655); where the two differ, the workflow governs. routine-delivery-loop is the executable driver that walks it, adding only what is specific to running it — cadence, surface, run budget, the stop conditions of one run, sequencing skill-build-ticket, skill-review-pr and skill-merge-pr. Routine sits at Layer 2, workflow at Layer 4 — the same loop seen from two layers.
