> ## Documentation Index
> Fetch the complete documentation index at: https://docs.mutagent.io/llms.txt
> Use this file to discover all available pages before exploring further.

# Questions and dependencies

> Answer an escalation, wait for pull requests or a closed issue, and distinguish a paused stage from deferred planning.

An **escalation** is a question that stops a stage until the Factory has a decision. Unlike a
plan or PR gate, it asks for input such as a behavior choice, a dependency or a recovery action.

## Answer an escalation

**1. Read the current question**

Check **Inbox → Waiting on you** or list open escalations. Read the question and its options
before answering. An answer to a previous question does not decide a replacement question.

```bash theme={null}
architech factory escalations list --json
```

**2. Send your decision**

Use the escalation ID, not the run ID. For an open-ended question, give the missing requirement:

```bash theme={null}
architech factory escalations answer "$ESCALATION_ID" "Keep the existing public API" --json
```

For a stopped stage with fixed choices, use an offered number or the exact choice text:

```bash theme={null}
architech factory escalations answer "$ESCALATION_ID" "Retry the stage" --json
```

If the question is on a bound issue or Factory PR, reply where it was asked. If it was posted to
Slack, reply in that question's thread. Use the CLI if delivery or identity is uncertain. The
Factory ignores its own replies. Comment replies are not authenticated the same way as gate
approvals; a stored GitHub reply can be held if its author's write access cannot be verified.

**3. Check what happened**

The first accepted answer decides the question. Usually the stage continues with your answer;
a dependency option can keep it waiting or defer planning instead. Check `runs show` before
sending another answer. Your local agent can relay your words, but shouldn't choose for you.

## Wait for a PR to merge

A wait mark belongs to an **option offered by the stage**, not to an arbitrary reply you type.
For example, a stage might offer this single-PR option or the list form:

```text theme={null}
1. Continue once the API change lands [wait-for-merge acme/api#42]
2. Continue once both changes land [wait-for-merge acme/api#42 acme/web#57]
3. Continue without the dependency
```

Choose the corresponding option by number (recommended) or its unambiguous printed text:

```bash theme={null}
architech factory escalations answer "$ESCALATION_ID" "2" --json
```

Use `owner/repo#number`, not a URL. The list has space-separated references inside **one** mark
with at most eight distinct PRs. Every PR in the selected list must merge before the same stage
can resume. An open or unreadable PR doesn't count. If a dependency closes unmerged, or the Factory
confirms an open dependency's owning run ended without landing, it replaces the wait with a
question. Read the replacement and decide whether to continue or cancel as offered.

## Wait for an issue to close

A board-bound plan can offer one issue dependency at the end of a labelled option:

```text theme={null}
1. Wait for the API contract [wait-for-close acme/api#64]
2. Plan with the current contract
```

```bash theme={null}
architech factory escalations answer "$ESCALATION_ID" "1" --json
```

This **defers planning**, rather than keeping the plan stage open. The Factory looks for the
GitHub issue to close or the latest Factory run for that dependency issue to finish as `DONE`.
Use one issue per option. The mark is not available to a boardless run.

## Recognize a deferred outcome

| What you selected | What happens |
| - | - |
| A regular PR wait | The run remains waiting; the stage resumes after all selected PRs merge. |
| A plan deferral for a single PR or issue | The current run ends as `DEFERRED`. For a board item the Factory writes On-Hold (if mapped). A resolved dependency can start a new planning run, if the item and binding still qualify. |
| An offered **Defer planning** option with no dependency | The run ends as `DEFERRED` without an automatic dependency restart. |

A plan's explicit **Defer planning** option with a single PR mark can defer the run instead of
waiting in place. A list of PRs is for waiting in place, not for a deferred plan. Check the outcome
and dependency with `architech factory runs show "$RUN_ID" --json`.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.