Message controls

Chat isn't a one-way stream — every message and every reply has controls attached. Once you know them, you can iterate on complex prompts without starting over.

The basics:

• Enter — send the message
• Shift+Enter — newline (multi-line messages)
• Cmd+Shift+Enter (macOS) / Ctrl+Shift+Enter (Linux) — prompt optimizer: rewrite the vague version into a scoped, actionable one before sending
• @filename — attach a file from the active project directory (fuzzy search opens automatically)

Concurrent messages are queued FIFO — safe to type-and-send multiple in a row.

While the agent is streaming a response click ⏹ Stop on the tab header. The current turn is cancelled. Any partial response and completed tool calls are preserved; the next queued message runs next.

In Slack, the !stop command does the same.

Hover any user message and click Edit. The message becomes editable in place.

• Changing the text and pressing Enter replays the conversation from that point — everything after is discarded and regenerated
• Cancelling leaves the conversation untouched
• The original text is kept in local history so you can compare drafts

Use this to iterate on a prompt: send a first attempt, see how the agent responded, edit and refine.

Hover the last agent response and click ⟳ Regenerate to retry the turn.

Regenerated replies are stored as variants on the same message. Use the ◀ ▶ arrows on the reply to flip between attempts.

• Variants share the same input message
• Only the currently-displayed variant is part of the conversation the agent sees
• Deleting a variant deletes it from the local history

Combine with model selection to compare responses across models: switch model, regenerate, flip variants.

Fork clones the current session into a new tab.

• Fork with full context — the new tab starts from the current state with the entire conversation carried over
• Fork tail-only — only the recent messages are carried over (useful when you want the context of the last exchange but not the whole thread)

The forked tab is fully independent from that point — messages sent in one don't reach the other.

When a tool call completes, its result appears in the timeline. Hover the tool call:

• ↶ Undo — for file writes and other reversible operations, restore the pre-tool state
• ↷ Redo — reapply an undone operation
• Copy result — copy the tool output to the clipboard

Some tool categories aren't undoable (execute_bash, network calls). Those show a disabled undo button.

When approval is required (interactive mode, not auto or trusted):

• Approve — run the tool call
• Reject — refuse the tool call; the agent sees the rejection and can try a different approach
• Trust this command — session-scoped auto-approval for this exact tool + args
• Trust this tool — session-scoped auto-approval for the tool with any args
• Yolo — 6-hour global auto-approval

More on trust levels in Security.

Some tool calls — specifically AskUserQuestion — render as structured option cards rather than free-text responses. Click a card to answer; your choice is fed back to the agent as the tool result.

Type / at the start of a message to see the slash command menu:

Full slash command reference: CLI reference.

You can also edit agent responses, but with a caveat: this is a local edit only — the LLM's understanding of the conversation still uses the original response until you /compact or the session is reset. Use this to correct a formatting issue in something you're going to copy out, not to change what the agent "thinks" it said.

Some messages arrive from automated sources — cron notifications, subagent completions, or workflow injections. These are marked in the UI:

• Cron notification — a scheduled job sent a message that triggers an agent turn
• Subagent completion — a background subagent finished and injected its result
• Context injection — silent background context added by a hook or app

Injected messages are treated as automated input, not user input.

Interactive mcwidgets can send events back to the session:

• Widget JavaScript calls window.parent.postMessage({type: 'kirocrew:action', ...}, '*')
• The parent session receives a [Widget action event] message
• The agent can respond, update the widget, or trigger further tool calls

This lets you build small interactive UIs (buttons, forms, dashboards) that live inside the chat and drive further agent work.