#1804: feat(ux): surface session-control slash commands as visible WebUI actions

Summary

Please make common Hermes WebUI slash commands discoverable as first-class UI actions, not only hidden text commands.

Immediate user workflow:

“How do I start a fresh /new session inside a chat?”

That led to a broader question: users should not need to memorize /new, /clear, /steer, /interrupt, /queue, /stop, etc. for core chat/session control. These commands are valuable, but many of them are currently only discoverable if the user already knows to type / or reads docs.

Current behavior

From the current WebUI behavior/code, several core actions already exist as slash commands:

Session/view controls

• /new — starts a new chat session.
• /clear — clears the current conversation state/view.
• Hermes CLI documents /new and /reset as aliases for a fresh session, but WebUI appears to register /new rather than /reset.

Active-run / busy-state controls

• /stop — cancels/stops the active stream.
• /queue <message> — queues a message for the next turn.
• /interrupt <message> — cancels the current turn and sends/queues a replacement message.
• /steer <message> — injects a steering hint mid-task without interrupting where supported, with fallback behavior.

The WebUI also has a busy-input mode setting, but the per-message overrides are still slash-command oriented.

Other command-style controls that may deserve the same pattern

• /retry
• /undo
• /title
• /compress / /compact
• /background
• /btw
• /status
• /usage
• /model
• /reasoning
• /yolo

The request is not that all of these need large buttons. The ask is for a coherent discoverability and action-surface design so common actions are available without remembering slash syntax.

Requested UX

Add visible UI affordances for common commands, ideally backed by the same internal command handlers so slash commands and UI actions cannot drift.

Suggested design options:

1. Composer action menu / command palette

   • A +, lightning bolt, keyboard icon, or command-palette button near the composer.
   • Shows grouped actions with descriptions and slash equivalents.
   • Example groups:
     • Session: New chat, Clear conversation, Retry, Undo, Rename/title.
     • Active run: Stop, Queue message, Interrupt with message, Steer with message.
     • Context: Compress/compact.
     • Model/session: Model, Reasoning, YOLO.

2. Visible busy-state controls

   • When an agent is running, surface quick actions for:
     • Stop (/stop)
     • Queue next message (/queue)
     • Interrupt and replace (/interrupt)
     • Steer current run (/steer)
   • These should explain the difference clearly:
     • Queue = “run this after the current response finishes”
     • Interrupt = “stop current response and use this new instruction instead”
     • Steer = “nudge the current run without stopping it”
     • Stop = “cancel current run”

3. Visible session actions

   • New chat / fresh session action equivalent to /new.
   • Consider supporting /reset as a WebUI alias for CLI parity.
   • Clear current conversation action equivalent to /clear.
   • Make the distinction from “New chat” explicit:
     • New chat creates a separate fresh session.
     • Clear affects the current conversation/view/session state.

4. Tooltips and help

   • Tooltips should include slash equivalents, e.g. Steer current run (/steer).
   • /help or a visible ? menu should list both the slash command and the matching UI action where one exists.

5. Busy-state safety

   • If a command/action is invalid while busy or idle, disable it with a clear tooltip or explain what will happen.
   • Avoid silently queueing session-control commands like /new as text when the user intended a UI/session action.

Why this matters

Slash commands are powerful, but for WebUI users they are easy to miss. A user looking for a fresh chat or mid-run correction naturally scans the UI before guessing text commands.

This is especially important for:

• new users coming from graphical chat apps,
• users switching between CLI and WebUI,
• long-running agent tasks where /steer, /interrupt, and /queue are crucial but subtle,
• busy sessions where typed slash commands may not be intercepted the way users expect,
• mobile/responsive layouts where command discovery is harder.

Related issues / not duplicates

Related command and CLI-parity work exists, but this request is specifically about making commands visible/discoverable as WebUI UX/UI actions, not just adding slash-command support:

• #460 — surface skill slash commands in autocomplete
• #462 — /background, /btw, /undo session commands
• #720 / #784 — queue/steer/interrupt/background slash-command parity
• #843 — reasoning-level UI/discoverability
• #1792 — new-chat sidebar/update behavior while streams are active

Acceptance criteria

• A user can start a fresh chat session from the WebUI without knowing /new.
• A user can clearly distinguish “New chat/session” from “Clear current conversation.”
• A user can discover and invoke /steer, /interrupt, /queue, and /stop style active-run controls without memorizing the slash syntax.
• UI actions use the same command/session code paths as the slash commands where practical.
• Tooltips/help expose the slash equivalents.
• Busy/running-agent states are handled intentionally rather than accidentally queueing session-control commands as text.
• Responsive/mobile layout remains usable.

Suggested labels

enhancement, ux, commands, cli-parity