[FEATURE] Add a flag that tells Claude Code to emit long lines for prose/markdown content and let the terminal emulator handle word wrapping, rather than inserting hard newline characters at word boundaries

Found 3 possible duplicate issues:

1. https://github.com/anthropics/claude-code/issues/42296
2. https://github.com/anthropics/claude-code/issues/35905
3. https://github.com/anthropics/claude-code/issues/8276

This issue will be automatically closed as a duplicate in 3 days.

• If your issue is a duplicate, please close it and 👍 the existing issue instead
• To prevent auto-closure, add a comment or 👎 this comment

🤖 Generated with Claude Code

yes yes yes

The only fix is to restart the session with --resume, which is slow and disruptive This is especially painful for --resume sessions, where the entire conversation history is rendered at whatever width the terminal happened to be at launch time.

So is --resume a fix or a problem?
Edit: Ignore me, I think I misunderstood what you're saying.

> The only fix is to restart the session with --resume, which is slow and disruptive > This is especially painful for --resume sessions, where the entire conversation history is rendered at whatever width the terminal happened to be at launch time. So is --resume a fix or a problem?

Neither, it's a workaround. The real solution is that Claude avoids inserting newlines into the text stream and let the terminal handle word wraps, making reflow possible.

+1 on this. Concrete repro and workaround results from today on macOS + iTerm2:

Setup: Claude Code CLI in iTerm2, standard 80-ish column window.

Problem: Copying any multi-line prose output from the terminal and pasting elsewhere produces a newline at every visual line break. cat -ve on the clipboard confirms real $ (i.e. \n) at those positions, so the wrapping is hard, not a terminal soft-wrap.

Workarounds tried:

• COLUMNS=9999 claude — no effect. Claude Code appears to read terminal width via ioctl(TIOCGWINSZ) directly and ignores the env var.
• stty cols 9999 && claude — works for output width, but makes the interactive prompt unusable (cursor jumps past the physical window edge).
• claude -p "…" | pbcopy — works cleanly, output has no hard wraps. Not viable for interactive sessions though.

Ask: a settings.json key (e.g. wrapOutput: false) or a CLI flag (--no-wrap) that leaves prose/markdown unwrapped and lets the terminal emulator do soft-wrapping. Code blocks can keep their current behavior.

The -p pipe result proves the non-wrapped path already exists internally — surfacing it as a user-facing toggle would unblock the copy-paste workflow without a rewrite.

Reproduces in tmux on pane resize — also breaks URL highlighting

Hitting this in tmux (macOS). The two concrete pain points:

1. Word wrap breaks on pane resize

• Open Claude Code in a tmux pane at any width
• Resize the pane (drag, or use a layout command like prefix + {)
• Scrollback content stays hard-wrapped at the original column width — vast empty space on the right, or text spilling past the pane edge depending on direction
• Only workaround: claude --resume in the resized pane to re-render at the new width

2. Wrapped URLs lose clickability

• When a URL falls near a line boundary, the hard \n splits it mid-URL
• Terminal hyperlink detection only picks up one fragment — the clickable highlight covers only part of the URL
• Repros consistently with any long URL (e.g. GitHub issue links) in a narrow-ish pane

Both issues share the root cause described here. The --no-word-wrap / OSC 8 approach would fix both.

I'm trying to run claude within tmux windows - this would be a huge quality of life improvement

Yes please this is so annoying... Claude is linebreaking all markdown content when it writes it, including github issues and pr descriptions

Strong +1, and I want to add an angle that I think is underrepresented in the related threads (most of them focus on the TUI render / copy-paste from stdout): the same hard-wrapping habit also leaks into the content Claude writes to disk and to git — commit message bodies, PR descriptions, .md/.txt files, docstrings and long code comments. Those get persisted with hard \n at ~72/80 columns and then look broken forever in any soft-wrapping viewer (git GUIs, GitHub's web UI, modern editors) — sentences chopped mid-line, sometimes mid-word.

This is arguably worse than the terminal-reflow case because it's not just a display artifact you can re---resume away: it's baked into the committed artifact. A teammate reviewing the commit in a GUI sees the mangled wrapping permanently.

The current workaround is a CLAUDE.md instruction telling the model to never hard-wrap prose, which helps but is fragile — it's a deeply ingrained generation habit, so it regresses in long sessions and isn't reliable enough to trust for commits.

So my ask is that whatever flag/behavior comes out of this (--no-word-wrap / CLAUDE_NO_WRAP=1) ideally cover both surfaces:

1. TUI stdout (emit long lines, let the emulator soft-wrap — as described in the issue), and
2. Generated file/commit/PR content (write one logical line per paragraph, blank line between paragraphs, preserve only structural newlines: lists, headings, table rows, code fences).

The structural-vs-arbitrary distinction the issue already draws is exactly right; it just needs to apply to written content too, not only the terminal.

for anyone who lands here, quick hack: press ctrl+o twice, it reloads the transcript for the current terminal size!

**+1 — the hard newlines make Claude Code's prose hard to reuse for writing/drafting, which is a big part of why I use it.**

The problem isn't how the text looks in the terminal — it's what happens the moment I copy it out. Claude Code inserts a real \n at every wrap point, so one paragraph lands in my clipboard as a dozen hard-wrapped fragments:

Here is a paragraph Claude wrote. It's one logical thought,
but because the terminal happened to be ~60 columns wide when
it rendered, it now has four hard line breaks baked in that
were never part of the actual content.

Paste that into anything I draft in — a Markdown doc, a PR description, release notes, an Obsidian/iA Writer note — and I've imported four hardcoded breaks that don't belong. Now:

• To edit a sentence in the middle, I have to manually rejoin the lines first.
• The text won't reflow when the container width changes.
• Diffs get noisy — a one-word change re-wraps and touches several lines.

Every serious writing/editing tool treats one paragraph = one line and lets the editor do the visual wrap. In VS Code that's Option+Z (Toggle Word Wrap); Obsidian, iA Writer, Typora — and Markdown itself — all work this way. It's basic editing ergonomics: you think and edit in sentences and paragraphs, not in visual line-fragments. Right now Claude Code is the one tool in the chain that bakes the visual wrap into the content, so it breaks that everywhere downstream.

Ask: an option to emit prose/Markdown as unwrapped logical lines (one line per paragraph) and let the terminal handle soft-wrapping — e.g. --no-word-wrap, a CLAUDE_NO_WRAP=1 env var, or the outputWrapping: "soft" config key proposed in #24224. Terminals (iTerm2, tmux, etc.) already soft-wrap long lines for display and omit the newline when you copy a soft-wrapped line — so the terminal view stays fine and the copied text is clean, reflowable Markdown.

This would make Claude Code's output directly reusable for drafting instead of something I have to de-wrap by hand every time.