Interactive Commands

All commands are typed at the TUI prompt, prefixed with /. Unknown slash commands are submitted to the agent as regular text (useful for paths starting with /).

Session Management

/undo requires a checkpoint from the previous turn. In a Git workspace, every file is restored to its pre-turn tree without changing the user's Git index; files created during the turn are removed, while files that were untracked before the turn are restored. Outside Git, Cast restores files changed through its write and edit tools from shadow backups. Arbitrary changes made through bash or an MCP tool in a non-Git workspace cannot be reversed. /undo is refused while the agent is running (use /abort first) and is a no-op if there is nothing to undo.

Removing files created during the turn also removes any you created in that window — the restore cannot tell them apart, and they cannot be brought back. When there are such files, /undo names them and asks before proceeding; over the web API it refuses and asks you to re-run as /undo --force. --force skips the question.

/fork leaves the original session unchanged and starts an independent new session with the context currently sent to the model. It deliberately does not restore compacted-out history, copy checkpoints or pending pickers, or create a Git worktree: both sessions use the same working directory unless you switch one with /worktree.

Model and Provider

Persona

See Personas for the full list.

Skills and MCP

Bare /skills / /mcp = multi-select toggle. list is read-only. uninstall always confirms (picker or typed). See Skills and MCP.

Hot-reload vs /reload

You never need to quit cast or start a new session for these changes. The current chat continues.

/reload only re-scans cwd resources — it does not reset the conversation.

Rules

See Rules for rule types and creation.

Plan Mode

See Plan Mode for the full workflow.

Autonomous and Self-Verification

/goal [N] <description> runs one autonomous turn that keeps iterating (tools → verify → fix → repeat) until the goal is met, without yielding back to ask for permission. At most one clarifying question (via the question tool) if the goal is genuinely ambiguous. A leading number (/goal 10 …) sets the iteration budget yourself — or use --steps N. By default the run is bounded to 25 model calls. Each model call can carry several tool calls, so the budget is a ceiling on LLM turns, not on individual tools. Near the cap the model is nudged to wrap up, and if it burns through anyway a warning fires and the run stops — it never loops forever on unproductive tool calls. Note: a tight budget can cut a long task short before it's finished, so size it to the task. Use it for start-to-finish tasks: "fix the tests", "set up the project and make the first commit", "implement X and verify it runs". Works in the TUI and the web composer.

/code-review [range] [-- path…] reviews a change rather than the session. What must not go wrong is computed first, in code: which files are in scope (staged, unstaged and untracked against HEAD, or any git range you pass), which are filtered as generated, vendored or binary — each named with its reason so nothing looks silently missed — how they group into review units (a large file alone; a test with its implementation; otherwise by directory, capped), and which language rules apply. Only the judging is left to the model.

Findings go through a review_report tool that checks each one against the file: a line that doesn't hold is moved to where the quoted code actually is, and a finding whose code is nowhere in the file — or whose file is outside the scope — is dropped before you ever read it. A finding on a line the change didn't touch is kept and flagged as context.

copy/code-review                          # working tree vs HEAD
/code-review main..feature            # a branch's changes
/code-review HEAD~3..HEAD -- src/     # narrow a large change to one subtree

Rules live in prompts/review-rules/ — one document per language, loaded only for the languages actually in the diff, plus a shared default whose two standing orders are precision over recall (a false positive costs the trust you need for the next finding) and don't duplicate the toolchain (whatever the linter, formatter, compiler or test run already says is not a review comment). Add your own by dropping a file in that directory.

/review asks the agent to verify its own most recent work: identify what changed (git diff / touched files), find and run the project's test and lint commands, and report honestly what was verified and what remains open — it never claims a check it didn't actually run.

Steering

Just type. A plain message sent while the agent is running is steered into the running turn — no command needed, in the TUI and the web UI alike. /steer stays for when you want to be explicit (and for scripts).

These commands work while the agent is running:

/steer interrupts the current turn with new context — the message is injected immediately into the conversation, and the agent sees it on the next tool-call iteration. Useful for correcting course mid-execution.

/queue saves a message to run after the agent finishes its current turn. The message becomes a new turn automatically.

If nothing is running, both /steer and /queue submit the message as a normal prompt.

/abort stops the current run and clears both the steering and follow-up queues — anything queued before the abort is discarded.

Both steering and follow-up messages reset the doom loop counter — repeating a failing command after user guidance is treated as a new attempt, not a loop.

Context and Usage

Token usage and context size are shown automatically in the TUI status bar (prompt tokens in, completion tokens out, prompt-cache hit %, cost, context percentage, tokens/second, and sub-agent tokens).

Use /statusbar to toggle individual segments on/off and reorder them — useful on narrow terminals where the full bar overflows. Segments can be moved between the left and right sides of the bar with ←/→, and reordered within each side with j/k. Default: persona, mode, model (left) and elapsed (right); enable others via /statusbar.

Configuration

Utility

Keybindings

Esc stops the current turn while generating (twice within 2s); Ctrl+L clears the input in any state.

Tab completes a slash command in the palette, and a path-shaped token anywhere else (one containing /, or starting with ~) — ambiguous ones list what is left to choose from. Tab in ordinary prose does nothing.

Line breaks: Shift+Enter and Alt+Enter need a terminal that reports modified Enter (the Kitty keyboard protocol or modifyOtherKeys); everywhere else, end the line with a backslash and press Enter.

A long draft wraps at the terminal's edge, on word boundaries. The composer draws at most three rows and follows the cursor, with ↑/↓ in the prompt column where the draft continues past them — ↑/↓ move between rows, wrapped ones included.

Ctrl+C — press twice within 2s to exit. Does not stop a turn — use Esc for that.

During a Running Agent

Typing a plain message steers the running turn — no command needed. Besides that, these commands are accepted while the agent is executing:

• /steer / /s — inject context
• /queue / /q — queue follow-up
• /queue-reset / /qr — clear queue
• /abort / /stop — stop the run

All other input is rejected with a notice. Use Esc to stop the current turn (clears input when idle).