hermes - 💡(How to fix) Fix Feature request: transaction/draft mode for multi-message instructions

Feature request

Add a transaction/draft mode for Hermes conversations, so users can collect multiple messages as a draft and only execute them after an explicit commit.

Problem

On messaging platforms such as Telegram, users often send requirements in several short messages. Today, each message can immediately enter the agent loop and trigger tools/background agents before the user has finished specifying the request.

Existing related commands are useful but do not cover this workflow:

• /queue queues individual messages as separate turns.
• /steer injects a message into an active run.
• /busy queue|steer|interrupt controls behavior while the agent is busy.
• /goal is for persistent goals, not a temporary multi-message draft.

None of these provide “begin collecting messages, do not act, then execute exactly once when I say commit”.

Proposed UX

Add a draft/transaction command family, available in CLI and gateway sessions:

/draft begin              # start collecting messages; agent does not execute them
/draft show               # show current collected draft
/draft amend <text>       # append/edit explicitly, optional because normal messages append while draft is open
/draft commit             # combine the draft into one user message and execute once
/draft cancel             # discard draft

Possible aliases:

/transaction begin|show|commit|cancel
/commit                   # when a draft is open
/rollback                 # cancel draft

Desired behavior

When a draft is open:

1. Normal user messages are appended to the draft instead of being passed into the agent loop.
2. Hermes replies with a short acknowledgement such as “added to draft; use /draft commit to run or /draft show to inspect”.
3. /draft commit creates one consolidated user turn and starts the agent once.
4. /draft cancel discards the draft without side effects.
5. The feature should work consistently across CLI and gateway platforms, especially Telegram.

Why this matters

This reduces accidental premature execution, especially for users who send fragmented requirements from mobile chat apps. It also helps with expensive or side-effecting tasks where the user wants to finish describing scope before the agent dispatches tools or background coding agents.

Compatibility notes

• This should be distinct from /queue: queue preserves multiple separate future messages; draft mode merges them into one committed instruction.
• This should be distinct from /steer: steer modifies an already-running turn; draft mode prevents execution until commit.
• Draft state should be per session/chat/thread, not global.
• Drafts should probably expire after a timeout or be cleared on /new / /reset.
• The commit step should preserve role alternation by injecting a single user message into the normal conversation flow.

Implementation sketch

Potential areas to touch:

• hermes_cli/commands.py: add command definitions and help text.
• cli.py: add CLI draft-state handling before dispatching normal input to the agent loop.
• gateway/run.py or gateway session layer: intercept messages while a draft is open and append instead of invoking the agent.
• A small shared draft-state helper/module, ideally profile/session-aware.
• Tests for command parsing, CLI behavior, and gateway message interception.

Alternatives considered

Use /queue or /busy queue, but those still treat each message as an independent turn and do not provide rollback or a single final committed instruction.