Asking you

ask_user puts a question to you and waits. The agent uses it when the work forks on something only you can settle (which of several shapes to build, which of several directions to take) and guessing would put the whole turn's output on the wrong side of the fork.

It is one of the four tools that reach nothing outside crucible: no file, no process, nothing that leaves the machine. So no mode asks about it, and a rule can only be about the whole tool: deny ask_user refuses every call to it.

Argument	What it is
`questions`	Every question to put, in the order to answer them. Required, and at most 4.
`heading`	Two or three words naming one question, shown in a row of all of them. Required, and at most 24 bytes, because the row holds every heading at once.
`question`	The question itself. Required, and at most 500 bytes.
`several`	Whether more than one of its answers may be chosen. Left out means one.
`answers`	The answers it offers, best first. Required, at least 2 and at most 8, and no two the same.
`answer`	What one answer is called. Required, and at most 500 bytes.
`says`	One line saying what choosing it means, where the name does not say it. At most 500 bytes.
`recommended`	Marks the one answer the agent would pick. At most one per question, and the first listed; a call that marks two, or one that is not first, is refused so the agent can correct it.
`shows`	What the answer would look like, row by row. At most 10 rows of at most 500 bytes each.

What you see

A panel where the prompt box was: the questions across the top, the one you are on marked, then that question and its answers numbered under it.

╭──────────────────────────────────────────────────────────────╮
│  Questions for you                                           │
│                                                              │
│  › ✓ Language   □ Support   □ Status line   Review           │
│                                                              │
│  Which language should the examples be written in?           │
│                                                              │
│  › 1. Rust                                                   │
│       crucible's own implementation language                 │
│    2. Python                                                 │
│    3. Something else                                         │
│                                                              │
│  ──────────────────────────────────────────────────────────  │
│    4. Say it in the prompt instead                           │
╰──────────────────────────────────────────────────────────────╯
  esc to cancel · ←→ between questions · n for a note

A □ is a question you have not answered and a ✓ is one you have, so the row across the top is both where you are and how much is left. It appears only where there is more than one question.

In the list of answers, the one the agent would pick is the first, and its name ends with (Recommended). The label is only drawn: it is not part of the name you choose or that is sent back, so the read-back of several answers shows the name alone.

Where a question takes several answers, each one carries a bracketed mark of its own, [ ] and [✓]. Bracketed on purpose: the row above says whether a question is answered and these say whether an answer is chosen, and on that question both are on screen at once.

Two answers are always there and the agent does not write them. Something else is a line you type yourself, sent after whatever else you chose where several answers may be chosen. Say it in the prompt instead leaves the whole thing, which is what esc does too.

The keys

Key	What it does
`↑` `↓`	Moves down the answers. Stops at each end.
`←` `→`	Steps to the next question, or the one before. Stops at each end.
`enter`	Takes what is marked and moves on, or sends where there is nowhere left to move on to. On Something else with nothing written yet, it opens the line to write in instead. Where several answers may be chosen, it moves on without choosing the marked one: `space` does the choosing.
`space`	Where several answers may be chosen: chooses the marked one, or unchooses it.
`1`–`9`	Does what `enter` would on the answer with that number. Where several answers may be chosen, it chooses or unchooses that one instead, as `space` does. The row under the rule leaves the whole thing, when its number is 9 or lower.
`n`	Adds a line of your own beside the answer.
`esc`	Stops typing, if you are. Otherwise leaves the whole thing unanswered.

Going back to a question you have answered finds it as you left it, which is the reason the arrows go both ways.

Where an answer is a shape

Some questions are about what something will look like rather than what it is called. Those answers carry a specimen, drawn beside the answers where the window holds both whole, every answer unfolded and the widest specimen uncut:

│    1. Compact                     ┌────────────────────────────────────┐  │
│  › 2. With the workspace          │ › what shall we do about the test? │  │
│    3. Nothing at all              │                                    │  │
│                                   │ crucible · opus-5 · main* · 12.4k  │  │
│                                   └────────────────────────────────────┘  │

A window too narrow for that draws the box under the answers instead, at the full width, where it keeps most of the picture.

The box is the size of the largest specimen in that question and an answer with nothing to show says so inside it, so the panel does not change height as you move. A specimen runs to ten rows, and one longer is cut with a row saying how much was left.

Several questions at once

An ask of more than one question ends on a stop that reads every answer back before it goes, so nothing is sent that you have not seen:

│  These are the answers that go back:                         │
│                                                              │
│  ✓ Which language should the examples be written in?         │
│      Rust                                                    │
│  ✓ Which of these should crucible support later?             │
│      Reading images, Pulling text out of PDFs                │
│                                                              │
│  Send them?                                                  │
│                                                              │
│  › 1. Send                                                   │
│    2. Cancel                                                 │

An ask of one question has no such stop (a screen reading back one answer says what the screen before it said) unless that question takes several answers. There, enter would otherwise mean both choose this one and I am done, and a key meaning two things does the wrong one; the last stop is where being done happens instead.

Nobody answering is an answer

Leaving the ask is not an error and does not end the turn. The call comes back saying nobody answered and to ask in the prompt instead, and the agent carries on, usually by asking you the same thing in its own words, where you can reply however you like.

The same is true where the window is too short to stand the panel in. The questions are written into the transcript a row at a time instead, one key each.

Where it is not there

A run whose output is not a terminal has nobody to ask, so the tool is not registered at all, not even for tool_search to find. Piping crucible's output to a file is one of those runs.