fix: dedupe replayed context tail after compression

[LumenYoung]

Summary

• Dedupe replayed active-context tails before appending agent result deltas to the WebUI display transcript.
• Apply the same replay protection to persisted context_messages, so compression/continuation does not re-feed an already-present tail into the next model turn.
• Add a regression covering state.db/compression replay of an already-visible active tail while preserving normal append-only deltas.

Why this happens

WebUI intentionally keeps two related but different histories:

• messages: the visible transcript shown in the UI.
• context_messages: the model-facing context used to start the next turn.

Normally, when the agent returns result.messages, WebUI can treat it as:

previous_context + new_turn_delta

and append only new_turn_delta to the visible transcript/context.

During compression or session continuation, however, Hermes rotates/continues the underlying agent session and the state-db-backed result may include the previous model context plus a replay of the active tail before the newly generated turn:

previous_context + replayed_active_tail + new_turn_delta

That replayed active tail is not a new user/assistant/tool exchange. It is the same suffix that WebUI already has in messages and/or context_messages, reconstructed after the compression/continuation boundary.

The existing prefix-only merge logic only checked whether result.messages started with previous_context. Once that was true, it blindly appended everything after that prefix. In the replay case, that means WebUI appends replayed_active_tail as if it were fresh output, duplicating a whole contiguous block of user/assistant/tool messages.

Once duplicated in context_messages, the duplicated block is sent into the next turn as model context. That makes token usage jump unexpectedly after what appears to be a small/simple exchange, and can cause repeated compaction on subsequent turns.

When this happens

This is most likely to occur when all of the following are true:

1. A WebUI session is near the compression threshold or otherwise crosses a compression/continuation boundary.
2. The agent/session layer returns a state-db-reconciled result.messages sequence that contains the previous context prefix.
3. That returned sequence also replays the already-active tail before the new turn, for example:

summary/context marker
A: user asks something
A: assistant/tool work
A: assistant answer
A: user asks something        <-- replayed
A: assistant/tool work        <-- replayed
A: assistant answer           <-- replayed
B: new user/assistant turn

Before this fix, WebUI saw the whole suffix after previous_context as new, so it persisted the replayed A block again. The bug is not normal conversation growth; it is a merge/reconciliation artifact at compression/continuation boundaries.

State invariant repaired

After compression or session continuation, WebUI may receive a result whose prefix is the previous model context followed by a replay of the active tail from state.db. That replay is not a new turn.

Both histories should remain append-only with respect to genuinely new turns:

• visible transcript (messages) should not duplicate an already-visible suffix.
• model-facing context (context_messages) should not re-append an already-present suffix and feed it back into the next model call.

This PR strips the largest exact suffix/prefix overlap before appending result deltas. It applies the same protection to the display transcript merge and to persisted context_messages.

Test plan

• python -m pytest -q tests/test_issue1217_transcript_compaction.py
• python -m pytest -q tests/test_session_save_mode.py tests/test_issue1217_transcript_compaction.py
• git diff --check
• git merge-tree --write-tree origin/master HEAD