# The composer

Write in the composer at the bottom. Enter sends; Shift+Enter starts a new line. It starts one line
tall and grows with what you write, up to about ten lines, then scrolls. While it scrolls, its lines
fade a little at the top or bottom edge where more of the message runs on past it.

A session's panel and its transcript are in [The transcript](/docs/sessions-transcript/), and
sessions and the board in [Sessions and the board](/docs/sessions-and-board/). Files you send with
a message are in [Attaching files](/docs/sessions-attachments/).

The composer stands over the foot of the transcript. Scrolled up, the transcript's lines fade out as
they reach the composer's top edge, wherever it has grown to, and run on behind its glass. They fade
the same way under the header when there's more above. The newest line always stays just above the
composer.

The transcript keeps to its newest line as the agent writes, until you scroll up. Whatever you send
from the composer, a message, one that waits for the turn to end or a command, brings it back to the
newest line, however far up you'd read, and it keeps to it again as the reply comes. A message sent
from your phone or another window leaves this one where you're reading.

- Its toolbar holds, from left to right: the rephrase button (see
  [Rephrasing a message](#rephrasing-a-message)), **Attach files** (see
  [Attaching files](/docs/sessions-attachments/)),
  **Commands** (`/`, see [Conversation commands](/docs/conversation-commands/)), the permission mode
  (see [Permission modes](/docs/permission-modes/)), the model with its effort where the agent has
  one, the agent's own settings, the context ring, and **Send**. Where the toolbar has no room for
  each, the agent's settings fold into one **Settings** menu.
- With Claude Code the settings hold fast mode and the output style, and with Codex fast mode and
  its Daybreak unless your Codex turns it off (see
  [Configuration](/docs/configuration/#session-settings)).
- While a turn runs, **Stop** shows beside **Send** and ends the turn in progress. While only a plan
  waits for you, **Stop** stands in Send's place until you write something or add a file, and
  sending a message sets the plan aside (see [Questions and plans](/docs/questions-and-plans/)).
- A message you send while the agent works goes as the agent can take it (see
  [Sending while the agent works](#sending-while-the-agent-works)).
- Files can go on their own, with nothing typed.
- Right-click in the composer, or in any text field, for **Cut**, **Copy**, **Paste** and **Select
  All**. On macOS, a word underlined as misspelled first offers its spelling suggestions, each
  replacing it, then **Add to Dictionary**.
- When a message can't be sent, **Send** is held, and a line under the box says why.
- What you've written belongs to the session's composer: opening another session lets it go, and
  quitting with a message being written asks first.
- Above the composer, the agent's background tasks show while any run, closed under a heading that
  counts them until you open it, each with how long it has run, its **Output** ("No output yet."
  until there's some) and **Stop** (see [Configuration](/docs/configuration/#background-tasks)).

## Rephrasing a message

The stardust button at the left of the composer's toolbar has the session's agent rewrite what
you've written, in a run of its own beside the session. The conversation never sees it, and a turn
under way goes on.

- A click runs this computer's choice, **Rephrase** to start with, which rewrites your words
  without adding to them. Its tooltip names it, and [Settings](/docs/settings/#rephrase-button)
  changes it.
- The arrow beside it offers both: **Rephrase**, and **Rephrase and slightly enrich**, which adds a
  little where your message leaves something out. The one a click runs is marked **Default**.
- While it runs, the stardust breathes in the running colour (it holds still where your system asks
  for less motion, or while Moontors isn't the window in front), the message can't be edited, and
  **Commands** (`/`) and **Send** wait. A click on the button stops it, and leaves your words as
  they were.
- The new words, asked for as plain text with no Markdown formatting, take the place of yours in the
  box, and Undo (Cmd+Z on macOS, Ctrl+Z elsewhere) brings yours back. The files and the quoted row
  stay. If you've moved on to type somewhere else meanwhile, the new words go in without taking you
  away from it. Should your words change before the answer comes, as when **Edit** puts a waiting
  message back in the box, the new words are dropped and yours stay.
- When it fails, a line under the box says why, and your words stay as they were. An agent that
  hasn't answered after two minutes is stopped.
- It's held while nothing is written, while a command (`/…`) is, while a message is on its way,
  and while the session's agent can't run, as when it's signed out.
- The agent runs on the session's model with no tool, MCP server, plugin or hook, and nothing of
  the run is kept: no conversation is saved, and the session's history doesn't show it. It uses
  your account as a short message does.

## Sending while the agent works

Send whatever you like while a turn runs: nothing waits for the agent to be free first. While a turn
runs, **Send**'s tooltip says where what you send goes:

- **Send into the turn**, with Claude Code and Codex, while nothing waits for the turn's end: the
  agent takes your message in as it works. Until it does, your message shows last in the
  transcript, "Waits for the agent to take it in", after what the agent is doing; Claude Code takes
  it in once the tool it's running ends. Then it shows where the agent took it in, among the turn's
  rows. If the turn ends just as you send it, Codex's waits for the turn's end, as below. Claude
  Code may instead start a turn from it.
- **Send when the turn ends**, with Gemini CLI, which takes one message a turn, for a command with
  any agent, and for any message while something already waits, so nothing goes before what you
  sent first: it shows last in the transcript, "Waits for the turn to end", then goes once the turn
  ends.

### What waits for the turn's end

- A command waits for the turn's end, whether the agent runs it, as `/review`, `/init` or one of
  your own, or Moontors does, as `/compact` or `/clear`. The `/` list says "Runs when the turn
  ends" beside each while a turn runs. Those that only open or show something, such as `/mcp`,
  `/diff` or `/status`, and `/btw`, `/rename` and `/goal`, run at once.
- `/rewind`, `/branch`, `/cd` and `/add-dir` open their list or folder picker at once, and what you
  pick waits for the turn's end, its row saying what it'll do: the prompt a rewind or a branch goes
  back to before, or the folder a move goes to or an add lets the agent reach. `/subtask`, `/recap`
  and `/setup-default-sandbox` wait as you typed them. A waiting `/rewind` puts its prompt back in the
  composer at once, so what you send next goes after the rewind. A `/branch` that waited isn't
  opened for you: once it's made, the transcript says so, with **Open the branch**.
- **Fix**, from Claude Code's `/usage` (see [`/status`](/docs/insight-and-code-workflows/#status)),
  waits as a message would, its row showing the message it'll send, and the effort it sets first.
  It joins nothing, and nothing joins it.
- Each one waiting is a row of its own, last in the transcript, in the order you sent them. They go
  one at a time: each once the one before it has ended its turn, or, as `/clear`, is done.
- A message sent just after another waiting message joins it, after a blank line, with its files.
  A reply's quote goes with its own words. A command joins nothing.
- Each waiting row has **Edit**, which takes it out of the queue and puts it in the composer after
  anything you've written, with its files and the row it replied to, and **Discard**, which takes it
  away. A file it can no longer bring back, as one kept too long, is named above the composer.
- **Stop** ends the turn in progress and keeps nothing back. A message you sent into the turn that
  the agent hadn't taken in yet goes first, as the next turn's own, and shows where the agent takes
  it in. Then what waits goes, in order.
- If the turn ends with the agent failing, what waits stays where it is, each row saying "Waits:
  the agent stopped". **Send now**, on the first row, sends it, starting the agent again. Sending
  anything else lets the queue go on too, as does a turn that ends by itself.
- If your sign-in ends, each row asks you to sign in to the agent, as "Waits: sign in to Claude
  Code", and what waits goes once you sign in again.
- While what waits stays this way, Moontors' background service keeps it with the window closed,
  and an update's restart or **Remove Moontors' Data…** asks first, as for a message being
  written. An update you download and install yourself loses it, as the update notice says first;
  otherwise only the service being killed, or crashing itself, does.
- Each is checked again when its turn comes. One Moontors can't send or carry out then, as one
  whose files come to more than Gemini CLI takes, or a rewind to before a `/clear` that went ahead
  of it, stays first, the rows saying the agent stopped, and the transcript says why: **Edit** it or
  **Discard** it.
- Archiving or deleting the session takes what waits with it.
- A message sent within a turn is part of that turn, so **Rewind** and **Branch** go back to before
  the turn's own prompt, not to it.

## The model picker

The toolbar has two buttons side by side, each opening its menu: the model, and its effort where the
model has a choice. Each lists only what the agent offers, so a model's menu holds only the efforts
it takes.

- The agent's own default is marked **(default)**, as Opus 5.5 is on Claude Code, and checked
  while you've chosen none; the button says so too. Choosing it follows the agent's default as it
  moves, as when your account's default model changes. Any other choice stays as you chose it.
- Where the agent hasn't said which is its default, the menu starts with **Default model** or
  **Default effort** instead, as Claude Code's default effort is known only once the session's
  agent has started on the model.
- While a Codex turn runs, a model or effort you pick shows as chosen at once, with a clock beside
  it that says "Takes effect when this turn ends.", and switches when the turn ends, as a mode does
  (see [Switching](/docs/permission-modes/#switching)). Claude Code and Gemini CLI switch at once,
  even mid-turn. A change shows in the transcript as a quiet row.
- When no model can be picked now, both buttons are dimmed and a note beside them says why. A pick
  the session can't take, such as a model without fast mode while fast mode is on, is refused, and
  the reason shows above the composer.