One safety refusal used to lock the whole chat. Hermes fixed that.

It is late, and you ask the agent to summarise a page you just scraped. It answers politely that it cannot help with that request. You assume the page was too long, rephrase it — same answer. You try something completely unrelated, “forget that, look at this stack trace” — same answer again. From that point the window is dead. Nothing gets through, and the only way out is to close it and start over.
That is not the model sulking. It is the conversation’s own history locking itself. The bug was fixed on November 5, and the fix is more interesting than “don’t error out”: the refused turn is removed from what the model sees, while staying visible to you as a greyed, non-interactive block.
How one refusal locks an entire conversation
The important detail is how a content safety filter judges a request: not the newest message alone, but the whole thread. Your message plus the context around it form one judgement. Once that combination is judged unfit to process, the same combination will be judged unfit again — that is exactly the point, so nobody can slip past the filter by rewording a few words.
The bug was in what happened to the refused turn afterwards. Hermes treated it as an ordinary failure: it persisted the turn into the conversation, and the next request read the whole history back out and sent it again. So the history became:
- your original message (still there)
- the refusal (still there)
- your new question (appended)
At step 3 the filter is shown 1 + 2 + 3 — the already-blocked combination is still inside. It refuses, and this refusal is persisted too. Repeat forever: every new message is submitted for judgement together with a tainted thread. Those “Hermes Bot stuck session” reports all traced back here.
The fix: gone from the model, still on your screen
It landed in two steps, and the second one is the part users notice.
Step one (the feat(agent) commit): the content-policy handler stops carrying the turn forward. It hands the caller the pre-refusal history, so nothing from the refused turn enters the in-process message list; token usage is still flushed, but the turn is not persisted. The durable rows it had already written are soft-deleted in the turn’s finalizer — the same active=0 rewind that /undo uses. That has to happen after the turn lease releases, because mutating the transcript while the lease is held is refused.
Step two (the very next commit, titled “retain a safety-refused turn for display”): erasing it outright turned out to be too aggressive. A user who scrolls back and sees no trace of their own message assumes it never sent. So the turn is now retained for display, hidden from the model:
- Your message stays in the conversation, rendered as one greyed “refused — try a different query” notice, and it survives closing and reopening the session.
- It is tagged with its own display kind (
content_refused) and a stored notice string. - The tool rounds and the raw refusal detail stay soft-deleted, so the screen shows one clean notice instead of a pile of API errors.
- The model reads only active rows, so it sees none of it.
In one sentence: for the model the turn is gone; for you it is still there. That is the only arrangement that satisfies both requirements at once.
Every surface, not just the CLI
There is a single entry point for this: the CLI, the TUI, the gateway (Bot Chat included), ACP and subagents all funnel through the same facade, so the fix applies to all of them. The desktop got its own renderer too — a refused turn shows as a greyed, non-interactive block rather than a message you can click.
One distinction worth keeping straight: a content-policy refusal is not a denied approval. The latter is you (or a policy) refusing a tool call; the conversation is fine and you carry on. The former is the model service judging the content itself unfit. This post is about the former.
Not every failure should be treated this way
The most instructive part of the fix is what it deliberately did not generalise.
- A content-policy refusal is deterministic: the same history will be refused again, so keeping it buys nothing and costs the whole conversation.
- A 429, a timeout or a 5xx is transient: the next turn will probably work, and the context from before the failure still has value. Those keep the persist-and-replay path untouched.
- Context overflow is the other “this cannot grow” case, and it is handled the same way in spirit — do not re-feed input that is guaranteed to fail.
The test is one question: is this failure a property of the conversation, or of this one request? The first kind gets erased; the second kind gets kept.
When you do get refused
The notice was rewritten too, from a flat “your message was removed” to something that tells you what to do: that message has been left out of this conversation, so you are not stuck — just ask something else and you can keep going. Rewording it, removing any sensitive attachments, or switching models with /model can also help. If a later message is refused as well, start a new chat with /new (in a Bot Chat, archive it from its tab menu).
Each of those maps to something real: rewording changes the judged input, dropping attachments removes the most common trigger, /model changes which side runs the filter, and /new replaces the history that has already set in place.
If you would rather clean up history yourself, the /undo and /rewind line is still there — the Esc Esc write-up sorts out the four ways back. And the reason this fix can work at all — a conversation is several segments, with a display read and a model read that can disagree — is what session boundaries explains.
Can you use it today
These commits are on main (November 5, PR #149708 plus the commits around it) and they are not in the v0.23.0 tag, which was cut earlier that same day. So on a stable install a refused turn can still lock a conversation. If it happens, /new is the practical escape — not more rewording in the same window.
Update (2026-11-10): these changes shipped in v0.23.1 (November 9) —
hermes updateis enough. The “not in v0.23.0” statements above are still accurate; v0.23.1 closes the gap.
Worth separating from this: the pre-LLM policy hook is a layer you write yourself, running before the request is sent. That one you control — wording, scope, rules. This post is about the filter on the provider side, where all you can adjust is the input.
The takeaway
The value here is not “one fewer bug”. It is a pattern for a whole class of failure: a deterministic failure must not be left in the history, and the user must still see what happened. Soft-delete plus a display read that differs from the model read makes “the model cannot see it” and “the human can” true at the same time. Expect the same shape to be reused the next time a loop like this shows up.
And if you have a conversation that is currently stuck, open it after upgrading: the greyed notice should be sitting where your message was, and you can carry on from there.