Operator chat assistant

The Operator chat assistant is a floating, multi-tab panel that overlays every dashboard page. It slides down from the top of the viewport and stays available no matter which route you are on, so you can talk to the Operator, run quick status commands in an embedded terminal, or launch a coding-agent session without leaving the page you are working on. It is part of the dashboard layout — toggle it open and closed, and dismiss it with Esc.

This page covers the three tab types (chat, terminal, code), the slash commands you can run in the chat composer, the built-in commands of the embedded terminal, the split and pop-out layout, and the color schemes and display settings. To pair a browser and open the dashboard in the first place, see Run the dashboard; for a conversational walkthrough of talking to your agent, see Chat with your agent.

Tabs

The assistant is a tab strip over a single pane. Each tab is one of three kinds, and new tabs are created from the + button (which opens a chooser) or with a slash command. The strip scrolls horizontally when it overflows, and the settings and dismiss controls stay pinned on the right.

Tab	Icon	What it is
Chat	message	A live conversation with the Operator over a WebSocket session
Terminal	terminal	An embedded xterm.js terminal — a real PTY when available, with an API command fallback
Code	code	A CLI coding-agent session (Claude Code, Codex, OpenCode, Gemini) wired to the Revka MCP daemon

On first open the panel starts with two tabs: a Chat tab bound to the stable operator-main session, and a Terminal tab. Your open tabs, the active tab, and your display settings are persisted in localStorage, so the panel comes back the way you left it.

Renaming, closing, and restoring tabs

• Rename a chat tab by double-clicking its title. Press Enter (or click away) to save, Esc to cancel. The new name is persisted to the session backend with PUT /api/sessions/{id}.
• Close a tab with the × that appears on hover. Closing a chat tab archives its session (DELETE /api/sessions/{id}) and remembers it locally so it does not pop back. Closing the last tab opens a fresh chat tab.
• Restore happens automatically: on open, the panel lists recent dashboard sessions and restores chat tabs for those that still have messages and were not archived (up to 12), so an in-progress conversation survives a reload.

GET /api/sessions
Authorization: Bearer <token>

Note

Chat tabs are only mounted while they are visible or still doing live work. Switching away from a tab whose turn is still streaming keeps that tab mounted in the background so no chunks are lost, then unmounts it once the turn finishes.

Chat tab

A chat tab is a full Operator conversation. It connects over the gateway chat WebSocket, keyed by the tab’s session ID:

ws[s]://<host><base>/ws/chat?session_id=<session-id>&token=<bearer>

The connection negotiates the revka.v1 subprotocol. Because browsers cannot set an Authorization header on new WebSocket(), the bearer token is passed as the ?token= query parameter. The page context of the route you are on is sent with each message so the Operator gets page-specific instructions. For the full frame-by-frame protocol — message, steer, stop, streaming chunk/thinking/done, and every error code — see Realtime: WebSocket, SSE & Live Canvas.

Chat-tab features:

• Markdown rendering — assistant replies are rendered as GitHub-flavored Markdown; your own messages are shown verbatim.
• Streaming — the Operator’s response streams in live, with a sweep bar and a status line while it is responding.
• Activity cards — tool calls and their results appear inline in the stream as compact cards.
• Queue vs. steer — while a turn is in flight, a toggle beside the composer lets you either queue the next message (sent after the current turn) or steer the current turn (a mid-turn note applied at the next Operator boundary). Steering is text-only — it is disabled when you have an attachment staged.
• Stop — a stop button cancels the in-flight turn.
• Jump to latest — auto-scroll follows new output; scrolling up pauses it and shows a jump-to-latest button.
• Copy — every message has a copy button.

Attachments

Stage files for the next message with the paperclip button, by dragging files onto the composer, or by pasting an image from the clipboard. Each file uploads to the active session and is shown as a chip with its name and size:

POST /api/sessions/{session_id}/attachments
Authorization: Bearer <token>
Content-Type: multipart/form-data

{
  "file_id": "att_...",
  "filename": "screenshot.png",
  "size": 184320,
  "mime": "image/png",
  "session_id": "...",
  "created_at": "2026-06-18T..."
}

The returned file_id is what travels with your next message in the WebSocket payload’s attachments array. The gateway caps individual files at 25 MiB. Images are passed to vision-capable providers; text files are inlined into the prompt (with truncation if very large) — see Realtime for the inlining rules.

Terminal tab

A terminal tab is a real terminal built on xterm.js. On open it tries to attach to a PTY over the gateway terminal WebSocket:

ws[s]://<host><base>/ws/terminal?session_id=<id>&token=<bearer>&cols=<n>&rows=<n>

When the PTY attaches you get your login shell, full keystroke forwarding, resize support, and clickable links. The panel pre-sizes the PTY from the terminal’s measured columns and rows so the first paint matches the container. For the PTY protocol, supported CLI tools, and MCP auto-injection, see Realtime: WebSocket, SSE & Live Canvas.

API command mode

If the PTY WebSocket is not available — for example on a platform where the PTY module is disabled, or when the connection times out — the terminal falls back to API command mode. In this mode it is not a shell; it is a small built-in command runner that calls read-only gateway endpoints and prints the JSON result. Type a command at the ❯ prompt:

Command	Calls	Shows
status	GET /api/status	Runtime status (provider, model, health)
cost	GET /api/cost	Cost summary
agents	GET /api/agents	Registered agents
config	GET /api/config	Current configuration
sessions	GET /api/sessions	Active sessions
health	GET /api/health	Health snapshot
integrations	GET /api/integrations	Integration catalogue
clear	—	Clear the terminal
help	—	List these commands

Type help to print the list at any time. Unknown commands print an error and a pointer back to help. In API command mode the terminal supports basic line editing: Backspace, Ctrl+C to abort the current line, and Ctrl+L to clear.

Note

The terminal is themed by the active assistant color scheme (see Color schemes), and its font size and cursor blink follow the panel’s display settings.

Code tab

A code tab launches a CLI coding agent in a terminal, wired to the shared Revka MCP daemon so the agent has access to your Revka tools. It has a setup view and a running view.

In the setup view you pick a tool and a repository root, then start the session:

Tool	Notes
Claude Code (claude)	Spawned in a PTY
Codex (codex)	Spawned in a PTY
OpenCode (opencode)	Spawned in a PTY
Gemini CLI (gemini)	Spawned in a PTY
Revka Operator (operator)	Not a PTY — converts the tab into a Chat tab with the Operator context

The setup view probes the daemon first and shows a status line (Revka MCP: ready / checking… / not running):

GET /api/mcp/discovery
Authorization: Bearer <token>

When you start a PTY tool, the panel opens an MCP session and then attaches the terminal to it:

POST /api/mcp/session
Authorization: Bearer <token>
Content-Type: application/json

{ "cwd": "/path/to/repo", "label": "Claude Code · repo" }

The returned session_id and token are passed to the terminal WebSocket (/ws/terminal?tool=<tool>&cwd=<repo>&mcp_session=<id>&mcp_token=<tok>), and a second WebSocket subscribes to live tool-progress events:

ws[s]://<host><base>/ws/mcp/events?session_id=<mcp-session>&mcp_token=<tok>&token=<bearer>

Those progress events render as a strip of status cards above the terminal (tool name, progress, and a relative timestamp), so you can watch the agent’s tool calls advance. Recently used repository roots are remembered for quick reuse. For the session lifecycle and event payload schema, see Realtime: WebSocket, SSE & Live Canvas and MCP proxy & discovery API.

Tip

Choosing Revka Operator does not spawn a terminal — it turns the tab into a chat conversation scoped to the Operator coding context. Use it when you want the Operator to make the changes through its own tools rather than driving an external CLI.

Slash commands

In any chat composer, type / to open a filter-as-you-type menu of slash commands. Use the arrow keys to move, Tab or Enter to pick, and Esc to dismiss. A command with arguments prefills /<name> so you can type them; a command without arguments runs immediately.

Command	Aliases	Argument	Action
/help	/?	—	List the available commands inline
/clear	/cls	—	Clear the scrollback (the session stays connected)
/new	—	—	Open the new-tab menu
/chat	—	—	Open a new chat tab
/terminal	/term	—	Open a new terminal tab
/code	—	—	Open a new code tab
/attach	/file	—	Open the OS file picker to attach a file
/theme	—	<dark|light|oled|system>	Switch the UI theme
/lang	/language	<en|zh|tr|ko>	Switch the UI language
/close	—	—	Close the active tab

/theme dark
/lang ko
/clear

/clear only wipes the local scrollback — it does not delete the session or its persisted transcript. /lang persists your language choice to the runtime configuration.

Note

The /architect command exists only inside the workflow editor’s Architect chat panel, not in the dashboard assistant — it needs an open workflow to act on. See Workflows, editor & runs.

Layout

The assistant is a pop-out panel that slides down from the top of the viewport over the page, dimming the page behind it. Click outside it or press Esc to dismiss. Its height is configurable (see Display settings), and you can make it semi-transparent so the page underneath shows through — useful when chatting alongside a workflow editor or canvas.

Split chats

When the active tab is a chat, a split button appears in the action cluster. The first click spawns a fresh chat tab paired beside the current one; subsequent clicks toggle the split direction:

• Side-by-side (vertical split) — the two chats sit left and right.
• Stacked (horizontal split) — the two chats sit top and bottom.

A separate × un-splits. Split is only meaningful for two chat tabs; switching to a terminal or code tab hides the split (and restores it when you come back). Use it to keep two Operator conversations — or one conversation and one reference thread — visible at once.

Color schemes

The terminal and chat use one of four named color schemes, selected in the settings panel and persisted in localStorage (revka-assistant-config). The default is Revka.

Scheme	Feel
Matrix	Green-on-dark with a soft glow
Amber	Warm amber/orange with a soft glow
Revka	Cool blue (the default)
Minimal	Neutral grey, no glow

The scheme drives message colors, the cursor color, the glow accents, and the embedded terminal’s theme. It is independent of the dashboard’s light/dark theme (which you change with /theme or the header toggle) and of uploaded UI skins — see Logs, audit, doctor, pairing & skins pages.

Display settings

Open the settings panel from the gear icon to adjust the assistant’s appearance. These also persist in localStorage:

Setting	Range / values	Default	Meaning
Color Scheme	Matrix, Amber, Revka, Minimal	Revka	Accent and terminal theme
Font Size	10–20 px	13 px	Scrollback and terminal font size
Cursor Blink	on / off	on	Blink the composer and terminal cursor
Panel Height	25–90 %	60 %	Panel height as a share of the viewport
Panel Opacity	50–100 %	100 %	Whole-panel opacity; below 100 % the page shows through

Caution

The composer input is clamped to a minimum effective font size of 16 px regardless of your Font Size setting, to stop mobile Safari from auto-zooming on focus. Your chosen size still applies to the message scrollback above.

Related pages

Chat with your agent A conversational walkthrough of talking to the Operator from the dashboard.

Run the dashboard Start the gateway, pair a device, and open the dashboard.

Realtime: WebSocket, SSE & Live Canvas The chat, terminal, and MCP-events WebSocket protocols behind the tabs.

Cron, sessions & attachments API Session listing, rename, delete, and the attachment upload endpoint.

MCP proxy & discovery API Daemon discovery and MCP sessions used by code tabs.

Logs, audit, doctor, pairing & skins UI skins, which are distinct from the assistant's color schemes.