Original Request

and another feature - instead of ENTER to sbumit new message and interrupt, maintain a queue like Cursor IDE, and only if user ENTER with empty mes
sage, it enqueue mimedaitley, otherwais it will start

Agent's Two Cents (could be wrong)

Everything below is the AI agent's best guess based on the current codebase.
Take with a grain of salt — the original request above is the only thing that came from a human.

Suggested priority: p2

Problem / Motivation

Hermes CLI already supports interrupt-on-Enter, but that default is too trigger-happy for long-running work. The missing piece is a more natural, Cursor-style busy-input UX where users can keep drafting follow-ups without accidentally nuking the current run.

What We Checked

• cli.py already has display.busy_input_mode with interrupt vs queue (cli.py:1516-1518).
• Busy Enter already routes to _pending_input in queue mode instead of _interrupt_queue (cli.py:7659-7677).
• /queue <prompt> already exists as an explicit manual fallback (cli.py:4945-4955).
• Docs already describe queue mode (website/docs/user-guide/cli.md:216-231).
• Tests already cover the current queue-vs-interrupt split (tests/cli/test_cli_init.py:99-149).
• Related open issues already exist around queueing and busy-input UX: feat: dual queue — follow-up (Alt+Enter) + steering (Enter/queue mode) #5504, Feature request: Message queue for gateway (don't interrupt running agent) #4772, Message handling behavior when multiple messages arrive during active agent execution #5057.
• Similar composition-first busy-input behavior also exists in Claude Code, so this is not just a Cursor-specific expectation.

What still hurts

• The current queue support is config-driven and fairly hidden.
• Enter still feels semantically overloaded: submit, interrupt, or queue depending on state/config.
• There is no obvious Cursor-style or Claude Code-style "keep typing while busy, then explicitly send when ready" gesture.
• The requested empty-submit behavior is not implemented or documented.

Proposed Solution

Add a CLI busy-input mode oriented around composition first, submission second:

• While the agent is busy, let the input box behave like a draft buffer by default, aligning more closely with workflows users already know from tools like Cursor IDE and Claude Code.
• Do not treat every Enter as immediate submit/interrupt.
• Support an explicit blank-submit gesture: when the user presses Enter on an empty trailing line (or otherwise signals an empty-message submit state), Hermes enqueues the drafted follow-up immediately.
• Keep /queue as an explicit command, but make the zero-friction keyboard path first-class.
• Preserve interrupt mode for users who prefer aggressive redirect behavior.

Dependencies & Potential Blockers

No major blockers identified.

How to Validate

• Start a long-running CLI task.
• Type a multi-line follow-up while the agent is still working.
• Press Enter inside the draft and confirm Hermes does not interrupt the current run prematurely.
• Trigger the blank-submit gesture and confirm the draft is queued exactly once.
• Confirm the queued prompt runs automatically after the active turn completes.
• Confirm display.busy_input_mode: interrupt still preserves current interrupt behavior.
• Confirm /queue still works.

Best Validation Path

Run Hermes CLI with a deliberately long task, compose a follow-up during execution, and verify the full path manually: draft -> no interrupt on ordinary Enter -> blank-submit queues -> queued message runs after completion. Back this with focused CLI tests around the Enter handler and pending/interrupt queues.

Best Human Demo

A short terminal recording is the best demo: show a long-running task, type a multi-line follow-up during execution, hit normal Enter without interruption, then use the blank-submit gesture and show the queued prompt firing after the current run finishes.

Scope Estimate

medium

Key Files/Modules Likely Involved

• cli.py
• tests/cli/test_cli_init.py
• website/docs/user-guide/cli.md
• potentially hermes_cli/commands.py if keybinding/help text needs surfacing

Architecture Diagram

User keyboard input
        |
        v
+-------------------+
| CLI input buffer  |
| draft composition |
+-------------------+
        |
        | Enter while busy
        v
+-----------------------------+
| Busy-input policy           |
| - interrupt                 |
| - queue                     |
| - cursor-style draft/queue  |
+-----------------------------+
      |                 |
      | interrupt       | enqueue
      v                 v
+-------------+   +----------------+
| interrupt   |   | _pending_input |
| _queue      |   | FIFO follow-up |
+-------------+   +----------------+
      |                 |
      v                 v
 active run stops   active run finishes
      |                 |
      +--------+--------+
               v
        next agent turn

Rough Implementation Sketch

• Refactor the Enter handler in cli.py so busy-state submission policy is centralized instead of baked into a single immediate branch.
• Introduce a composition-oriented busy mode or sub-mode for blank-submit semantics.
• Track whether the current busy-state buffer ends in an empty line / explicit submit gesture.
• Add tests for single-line, multi-line, empty-line submit, and regression coverage for existing interrupt and queue modes.
• Document the behavior in CLI docs and config examples.

Open Questions

• Should this be a brand-new mode (for example draft_queue) or an extension of existing queue mode?
• Should blank-submit mean “buffer ends with an empty line” or “cursor is on a blank line and Enter is pressed again”?
• Should there also be an explicit hotkey like Alt+Enter or Ctrl+Enter for immediate queueing, alongside the blank-submit gesture?

Potential Risks or Gotchas

• Prompt-toolkit keybinding changes can get confusing fast if submit semantics differ too much between idle and busy states.
• Multi-line editing, slash commands, and pasted content can regress if the Enter routing becomes too clever.
• If the behavior is under-specified, users may accidentally queue drafts they thought were still being edited.

Related Issues

• feat: dual queue — follow-up (Alt+Enter) + steering (Enter/queue mode) #5504 — feat: dual queue — follow-up (Alt+Enter) + steering (Enter/queue mode)
• Feature request: Message queue for gateway (don't interrupt running agent) #4772 — Feature request: Message queue for gateway (don't interrupt running agent)
• Message handling behavior when multiple messages arrive during active agent execution #5057 — Message handling behavior when multiple messages arrive during active agent execution