fix(cli): stop reprinting streamed assistant text after 'Done' in non-compact text mode

[nankingjing]

Summary

Fixes #3258.

In non-compact text mode (and the interactive REPL), LiveCli::run_turn
prints the entire assistant response twice:

1. It runs the turn with emit_output = true, so AnthropicRuntimeClient::consume_stream
   already streams and renders every text delta to the terminal live
   (main.rs, ContentBlockDelta::TextDelta / MessageStop).
2. After spinner.finish("✨ Done") it then calls
   println!("{final_text}"), reprinting the whole message that was just streamed.

The reprint was originally added because Spinner::finish runs
MoveToColumn(0) + Clear(ClearType::CurrentLine) and would otherwise erase
the last streamed line (the streamed tail has no trailing newline). Reprinting
the full text "fixed" the erased line but duplicated everything above it.

Fix

Protect only the last streamed line instead of reprinting the whole message:

• When there is streamed assistant text, emit a single println!() before
  spinner.finish so the line-clear lands on a fresh empty line rather than the
  last content line.
• Remove the println!("{final_text}") reprint.

final_text is still computed and used to decide whether a newline is needed,
so the empty-response path (tool-only turns) is unchanged. Compact/JSON paths
use emit_output = false and print the message exactly once — they are
untouched.

Scope

• 1 file, rust/crates/rusty-claude-cli/src/main.rs (LiveCli::run_turn), +9 -4.
• No signature/API changes; no test depended on the duplicate output.

Verification

Verified by reading and tracing the streaming path (consume_stream writes each
text delta live when emit_output is true; prepare_turn_runtime(true) is used
by run_turn, while the compact/JSON paths use prepare_turn_runtime(false))
and by inspecting Spinner::finish's line-clear behavior. Not compiled or
executed in this environment (full Rust workspace build not available here).
The change is a local reordering plus removal of one println!; final_text
remains used, so no unused-variable warning is introduced.

[nankingjing]

Pushed one follow-up on top of #3273: extended the same newline-before-spinner.finish guard to the auto-compaction retry success path. That branch also runs with emit_output = true, so without the guard Spinner::finish would still clear the last streamed line on retries. Tool-only and compact/JSON paths remain untouched.

New head: 94e0859 (12 +4, single file). Local diff passes git diff --check; I could not run cargo test here (no Rust toolchain installed in this environment) — please flag if you want me to land a regression test that exercises the retry path before merge.

[1716775457damn]

Nice fix! The root cause is clear: spinner.finish clearing the last streamed line, and the original workaround of reprinting the full text was indeed overly aggressive. Protecting just the tail line before spinner finish is the right approach. The follow-up extending the guard to the auto-compaction retry path is a good catch too — that path has the same emit_output=true path and would have been affected. LGTM on the logic.

[nankingjing]

Thanks for the thorough review and for catching the retry-path exposure. That follow-up was important since the auto-compaction retry has the same emit_output=true path and would have had the same issue. Glad the approach landed cleanly.

[1716775457damn]

The approach of guarding just the tail line before spinner.finish is clean and minimal. Glad the retry path was also covered — that would have been an easy edge case to miss. This should noticeably improve the non-compact CLI experience.

[1716775457damn]

Confirmed the double-printing issue in non-compact mode — this was a real UX annoyance. The fix is clean, and covering the retry path as well was the right call. Thanks @nankingjing!

[1716775457damn]

Nice fix — the duplicate output in non-compact mode was confusing. The guard on !state.compact_output looks clean. Thanks @nankingjing!

[1716775457damn]

Thanks for the follow-up @nankingjing — extending the same newline-before-spinner.finish guard to the auto-compaction retry path makes sense. The fix looks clean with good scope discipline. 👍

[nankingjing]

Thanks for the review feedback @1716775457damn! All 6 PRs are green on CI. If you have a moment, could you submit a formal PR review approval (Review changes → Approve) on each? That would let them merge cleanly. Much appreciated!

[1716775457damn]

Approved. The root cause is well-documented: spinner.finish clears the last streamed line, and reprinting the full text was a blunt workaround. The newline-before-finish guard is the minimal correct fix, and covering the auto-compaction retry path was a good catch — same emit_output=true path, same symptom.