# Design requests

File a design request that blocks the task needing it, until a release of the design system closes it.

> **In the pilot**
>
> The design system module is in the pilot: it is on for pilot orgs first. An org admin can tell you whether your org has it.

A design request asks a design system's team for a part the system does not have yet. It is a task on the design
system, and the task that needs the part waits on it. A request is done when the part is released, not when its pull
request merges, so nobody builds on a part that is not out yet.

Requests need the `design` module on your org. Who can do what:

- **Any full member** files a request and reads the Requests page. A guest cannot file one.
- **Maintainers** of the system (and admins) triage: accept, assign, set priority and decline.
- **Contributors** on the system move a request between states, as on any board.

## File a request from the web

### Open the system's Requests page

Open the design system and choose the **Requests** tab. Press **File a request**.

### Describe the part

Give it a **Title**, then say **What it does** (the job the part would do) and **What you tried**. You can paste a
**Link**: a Jira or Linear ticket, or any https address. It is only a link; EasyCode never fetches or syncs it.

### Check similar requests

Before filing, the form lists **Similar open requests**. If one asks for the same part, press **Wait on this
instead**, and your task waits on that request rather than a new one.

### Say which task waits

Under **Which task waits on it**, pick one of your open tasks, or leave **No task waits**. Then press **File request**.

The request starts as **New**, unassigned. The system's maintainers are told; with no maintainer, the org's owners
and admins are.

## File a request from a session

When an agent proves a part is missing (see [Design in every session](/design-system/in-every-session)), choose "a
request". The agent first looks for an open request with the same job using `task_list`. When one fits, it makes your
task wait on it with `task_wait`. Otherwise it files one with `task_create`, of type `design.request`.

A request filed from a session carries the **Proposed part**: the prototype, its version and the part. The request
page opens the studio viewer on that part. A member who cannot open the prototype sees "A prototype you can't open"
and the markup in the description. To let the system's team see it, share the prototype with them.

## Wait on a request

The waiting task becomes **Blocked**. Its card reads "Waiting on" the request's title.

To make an existing task wait, open the task and press **Wait on a request**. The picker lists open requests, those of
the systems your product uses first; search by title, then press **Wait on this**. Anyone who may edit the task can add
or remove a wait. Removing the last open wait returns the task to todo. You cannot wait on a request that is already
done or declined.

## Triage requests

Maintainers work from the **Requests** page. Each row shows the title, its status, how many tasks wait, the assignee,
the priority, the outside link, and who filed it. Filters narrow by status (open by default) and assignee, and you can
search titles.

- **Accept** moves a request from New to Accepted.
- **Assign** and **Priority** set who works on it and how soon.
- **Decline** asks how many tasks wait and says they will stop waiting, then cancels it. Every waiting task is freed.

Contributors use **Move to** to change a request's state.

## From merged to released

A request's status follows its work:

| Status                                                                         | When                                                                    |
| ------------------------------------------------------------------------------ | ----------------------------------------------------------------------- |
| New                                                                            | Just filed                                                              |
| Accepted                                                                       | A maintainer accepted it                                                |
| In progress                                                                    | Someone is working on it                                                |
| In review                                                                      | Its pull request is open                                                |
| Merged, waiting for release                                                    | Its pull request merged into a repo of the system                       |
| "Released in" the system and version, such as "Released in Northwind UI 1.3.0" | A release holds the merge                                               |
| Done                                                                           | Closed by hand, or its pull requests changed none of the system's repos |
| Declined                                                                       | A maintainer declined it                                                |

When a release of each repo the request's pull requests touched holds the merge, EasyCode closes the request. Each
waiting task with nothing else open returns to todo, and its assignee is told. A request released once stays done,
even if that release is later withdrawn. A maintainer or contributor can still move a request to done by hand.

When a request filed with a proposed part closes, the prototype gets a comment on that part. On a release it says the
part is now in the system and to swap the proposed part for the component. On a decline it says to use the nearest
component.

## The Release task

When the system has release work, EasyCode opens one **Release** task on it. Release work is a request merged and
waiting for release, or a new release with no render catalogue. The Requests page shows a **Release work** banner that
links to it, and the task's **Release work** section lists the waiting requests and the releases to capture.

> **Desktop app only**
>
> **Capture on the desktop** opens the Release task in the desktop app, where a session captures the release's render
> catalogue. On the web, the task says to open it on the desktop.

The Release task closes itself when its work is empty. A maintainer can also finish or cancel it by hand.

## Next

- [Open changes across repos](/design-system/open-changes)
- [Workflows and the board](/guides/workflows-and-the-board)
- [The design system record](/design-system/the-record)
