# Conversation commands

Conversation commands are the `/` commands you type in a session's message box: Moontors' own, and
each agent's built-in commands that work in Moontors.

## The commands list

Type `/` at the start of a message to open the commands list above the message box. Keep typing to
filter it; Enter or Tab picks, and Escape closes it. The `/` button in the toolbar does the same.
`/help` lists every command the session has, with what each one does.

The list holds:

- the built-in commands Moontors supports for the session's agent;
- some of the agent's own commands that run as you type them, such as Claude Code's bundled skills
  (`/simplify`, `/debug` and others), and a few that open a page in your browser, such as
  `/upgrade` or `/bug`;
- your own custom commands and skills, from the agent's usual places, including your plugins' and
  extensions', and the skills Claude Code syncs from your claude.ai account. They work as they do in
  the agent's own terminal.

Each row shows the command, what it does, and its kind: **Command**, **Skill** or **Built-in**. One
an extension or a plugin brings says which, and one you found by another of its names shows that
name. While the agent lists its own commands, the list says "Loading commands…"; if it can't list
them, it says why, and Moontors' own commands are still there.

The list follows what the session's agent says it can run for your account. A command your account
doesn't have isn't listed. Once you've typed three letters of a command the session can't run, it
shows greyed out at the bottom of the list, saying why: not enabled for this account, a reason
Moontors doesn't run it, or that Moontors doesn't support it yet. Typing it whole says the same
under the message box. A command the agent offers that Moontors doesn't know yet is also named in
the session's Status.

## What a typed command does

- Moontors' own commands run in Moontors. They're never sent to the agent as text.
- An agent's other name for one of them runs the same thing: Claude Code's `/reset` and `/new` are
  `/clear`, and Codex's `/side` is `/btw`.
- An agent's own command that Moontors doesn't run is stopped before it's sent, and the composer
  says why. Where Moontors has its own way, it names it: Claude Code's `/model`, for example, points
  to the model picker.
- An agent's own command that runs as you type it, such as Claude Code's `/loop`, goes to the agent
  as text. A turn that `/loop` starts by itself is marked "The loop started a turn", and runs as
  any other: the card shows it working, and **Stop** stops it.
- With Claude Code, a command or skill of your own with the same name as one of Claude Code's runs
  as yours, as it would in Claude Code's terminal, and that command's other names still run Claude
  Code's. With Codex and Gemini CLI, the agent's own command keeps the name.
- A command or skill of your own with the name of one of Moontors' own commands can't run, as
  Moontors' runs in its place. It shows greyed in the `/` list, saying so: rename it to use it.
- Files can't go with a command the agent runs itself, such as `/review` or `/init`, and the
  composer says so. Moontors' own commands, such as `/compact`, leave the files in the composer for
  your next message. With Gemini CLI, a message that starts with `/` or `$` can't take files either,
  as Gemini CLI takes it as its own command. See
  [Attaching files](/docs/sessions-and-board/#attaching-files).

## The built-in commands

Not every agent has every one of these. Each agent's commands reference, for
[Claude Code](/docs/commands/claude/), [Codex](/docs/commands/codex/) and
[Gemini CLI](/docs/commands/gemini/), says what Moontors does with each of the agent's own commands.
Its "Moontors' own commands" section names the commands Moontors runs itself for that agent, and
the built-ins that agent can't run.

The other built-ins (`/diff`, `/export`, `/status`, `/rewind`, the configuration commands and
`/logout`) are in [Insight and code workflows](/docs/insight-and-code-workflows/) and
[Configuration](/docs/configuration/). `/archive` and `/delete` are in [Sessions and the
board](/docs/sessions-and-board/), and `/fast`, `/output-style` and `/autocompact` in
[Configuration](/docs/configuration/).

**`/clear`** starts a new conversation in the same session. The title, mode, model, worktree and
place on the board stay. The transcript marks it with "Context cleared", and the lines above it stay
visible. Not in a session with no conversation yet, and not while a turn is running. Not while the
agent's background tasks are running either, as it would stop them: stop them first.

**`/rename`** with a title renames the session. Without one, it opens the title for editing.

**`/btw`** asks a side question, even while the agent is working. The answer shows in a panel above
the composer. It's a throwaway: the agent answers from the conversation so far, with no tools, and
nothing of it is kept, in Moontors or by the agent. A new `/btw` replaces the last one. It needs a
turn the agent has finished, to answer from.

- The panel says "Thinking…" until the answer starts, and the answer streams in as the agent writes
  it. If the agent can't answer, or the question stops, the panel says why.
- Its X button closes it, and so does Escape.

**`/compact [instructions]`** compresses the conversation so it takes less of the agent's context.
With Claude Code, you can write instructions for the summary after it; Codex takes nothing after
it. A row shows it working, then the token counts before and after, and the agent's summary,
collapsed. When the agent compacts by itself, the same row shows. Not in a session with no
conversation yet, and not while a turn is running.

**`/review [instructions]`** reviews this session's changes: for a worktree session, everything
since the branch began; otherwise, the uncommitted changes. Anything you write after it goes to the
agent with the review, such as what to look for. The review shows as the agent's reply. It needs a
git repository.

**`/security-review`**, with Claude Code, runs Claude Code's own review of the pending changes for
security issues. Claude Code's review needs the repository to have an `origin` remote.

**`/init`** has the agent write its instructions file for this folder (`CLAUDE.md`, `AGENTS.md` or
`GEMINI.md`).

**`/branch`** starts a new session from before one of your prompts, and leaves this one as it is.
Pick the prompt from the list, or use the branch action beside the prompt in the transcript. The new
session has the conversation up to that prompt, and the prompt waits in its message box, for you to
change and send. The same rules as `/rewind` apply: not to a prompt before the last `/clear`, and
not past a point where the conversation was compacted.

- The list says "Reading the whole transcript…" while it loads, then asks "Branch from before which
  prompt?". A prompt you can't branch from is dimmed, with the reason under it.
- The confirmation names the prompt and says what happens, with **Cancel** and **Branch**.

**`/subtask <task>`** hands a task to a new session that starts with this conversation and works in
the background, while you carry on here. It works in this session's folder, or its worktree, and in
its mode, so its edits land in the same files as this session's own. When it finishes, its last
answer comes back to this session as a note, with a button to open the subtask's own session, whose
card lands first in the board's top row. The agent gets the answer too, ahead of the next message
you send it, though not with a command such as `/compact`; until then, a line under the message box
says reports are waiting. The transcript shows the reports under the message they went with, and an
export keeps them. A rewind to before that message sends them again with the next one, unless it
goes back to before the first message, which starts the conversation over. Not in a session with no
conversation yet, and not while a turn is running.

**`/cd [folder]`** moves the session to another folder, and the agent carries on with the same
conversation there from its next start. Give the folder as a full path; without one, it asks for a
folder. A worktree session stays in its worktree. Your home folder, the folders Moontors keeps its
own files in, and another session's worktree can't be the session's folder. Not while a turn or a
background task is running.

**`/context`** takes you to the context ring beside Send in the composer, which shows how full the
agent's context is. Until the agent has measured it, it says so instead.

**`/tasks`** goes to the agent's background tasks above the composer. See
[Configuration](/docs/configuration/). With none running, it says so instead.

**`/goal [goal]`**, with Codex, gives the agent a goal to work toward across turns. With a goal
after it, it sets that goal. Without one, it opens the **Goal** dialog with the current goal and how
it stands: you can change it, pause or resume it, or clear it. The transcript marks each change.

- The dialog says "Asking the agent for its goal…" while it asks, and "No goal yet. Write one for
  the agent to work toward." when there's none.
- How the goal stands: "The goal the agent works toward" while it's active; paused, until you resume
  it; blocked, when the agent can't go on with it as it is; held at your usage limit, or at its
  token budget; or **Done**.
- **Set goal** saves what you've written, once there's something written. **Pause** or **Resume**,
  and **Clear goal**, act on the goal as it stands. **Cancel** closes the dialog.

Works while a turn is running too. With a goal set, Codex may carry on working by itself. Such a
turn is marked "The goal started a turn", and otherwise runs as any other: the card shows it
working, and **Stop** stops it. With Claude Code, `/goal` is Claude Code's own command, sent as
typed.

**`/recap`**, with Codex, has the agent sum up the conversation so far, from its last eight
exchanges as Codex's own `/recap` reads them, and what it would do next.
The summary comes back as a note in the transcript. Not while a turn is running. With Claude Code,
`/recap` is Claude Code's own command, sent as typed, and its answer is an ordinary turn.

**`/setup-default-sandbox`**, for Codex on Windows, sets up the sandbox Codex runs its commands in.
It's in the list only on Windows. Windows asks for an administrator's approval once. This session
then restarts its agent to use the sandbox, keeping its conversation, and every other Codex session
uses it from its next start, unless your own Codex config picks another. While Windows asks, the
message box stays free and says the setup is under way. The transcript says when it's set up, or
that it already was. It's been tried on Windows 11.

To set it up, Codex creates local users, a group and firewall rules on the computer. The
[Privacy Policy](/policies/privacy/)'s steps for removing Moontors' data say how to remove them.

**`/approve`**, with Codex, lists the actions the agent's own review denied in this session, newest
first. Each also shows in the transcript where it happened. **Approve once** lets the agent try that
action again on its next turn, this one time only. With none, it says "Nothing was denied in this
session."

**`/help`** lists the session's commands, as the `/` list has them, with what each one does.