bramble: fix excessive line breaks in Codex thinking output (#41)

* bramble: fix excessive line breaks in Codex thinking output

Each streaming thinking delta from Codex was creating a separate
OutputLine, causing each word to appear on its own line with a 💭
prefix. Accumulate thinking deltas into a single line, matching the
existing text accumulation pattern.

Also consolidate AppendStreamingDelta into the session package so
both the live Manager and codexlogview replay parser share one
implementation with overlap-aware deduplication.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* Address PR review: fix truncation guards and show 💭 only once

- Exclude OutputTypeThinking from the post-switch single-line
  truncation guard in both output.go and view.go, since thinking
  content is now multi-line after accumulation.
- Update view.go's formatOutputLine to use the shared
  formatThinkingContent helper instead of single-line truncate.
- Show 💭 prefix only on the first line of thinking content;
  continuation lines are indented with spaces.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* Use plain concatenation for live streaming deltas in Manager

AppendStreamingDelta's overlap detection can produce false positives
for live streaming where deltas are non-overlapping token chunks
(e.g. "..." followed by "..." would be deduped). Revert the Manager
to plain += concatenation; keep AppendStreamingDelta only for the
codexlogview replay parser where protocol log deltas may overlap.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>

Author: mzhaom

bramble/app/output.go

@@ -156,7 +156,7 @@ func formatOutputLineWithStyles(line session.OutputLine, width int, s *Styles) s
 		formatted = s.Error.Render("✗ " + line.Content)
 
 	case session.OutputTypeThinking:
-		formatted = s.Dim.Render("💭 " + truncate(line.Content, width-4))
+		formatted = formatThinkingContent(line.Content, width, "", s)
 
 	case session.OutputTypeTool:
 		// Legacy tool type - kept for backward compat
@@ -197,10 +197,37 @@ func formatOutputLineWithStyles(line session.OutputLine, width int, s *Styles) s
 		formatted = line.Content
 	}
 
-	// Truncate if needed (skip for markdown content which may have multi-line)
-	if line.Type != session.OutputTypeText && runewidth.StringWidth(stripAnsi(formatted)) > width-2 {
+	// Truncate if needed (skip for multi-line content: markdown text and thinking)
+	if line.Type != session.OutputTypeText && line.Type != session.OutputTypeThinking && runewidth.StringWidth(stripAnsi(formatted)) > width-2 {
 		formatted = truncateVisual(formatted, width-2)
 	}
 
 	return formatted
 }
+
+// formatThinkingContent formats accumulated thinking text for display.
+// The 💭 prefix is shown only on the first line; continuation lines are
+// indented with spaces. prefix is prepended to every line (e.g. "  " for
+// the session-detail view).
+func formatThinkingContent(content string, width int, prefix string, s *Styles) string {
+	thinkingLines := strings.Split(content, "\n")
+	prefixLen := len(prefix)
+	// "💭 " occupies 3 rune-widths (emoji + space); continuation uses same indent.
+	iconPrefix := "💭 "
+	contPrefix := "   "
+	maxContent := width - prefixLen - 4 // room for prefix + icon/indent
+
+	var parts []string
+	for _, tl := range thinkingLines {
+		tl = strings.TrimRight(tl, " \t\r")
+		if tl == "" {
+			continue
+		}
+		lp := iconPrefix
+		if len(parts) > 0 {
+			lp = contPrefix
+		}
+		parts = append(parts, s.Dim.Render(prefix+lp+truncate(tl, maxContent)))
+	}
+	return strings.Join(parts, "\n")
+}

bramble/app/view.go

@@ -459,7 +459,7 @@ func (m Model) formatOutputLine(line session.OutputLine, width int) string {
 		formatted = s.Error.Render("  ✗ " + line.Content)
 
 	case session.OutputTypeThinking:
-		formatted = s.Dim.Render("  💭 " + truncate(line.Content, width-8))
+		formatted = formatThinkingContent(line.Content, width, "  ", s)
 
 	case session.OutputTypeTool:
 		formatted = "  🔧 " + line.Content
@@ -509,8 +509,8 @@ func (m Model) formatOutputLine(line session.OutputLine, width int) string {
 		formatted = "  " + line.Content
 	}
 
-	// Truncate width if needed (skip for markdown-rendered content which may have ANSI)
-	if line.Type != session.OutputTypeText && line.Type != session.OutputTypePlanReady && runewidth.StringWidth(stripAnsi(formatted)) > width-2 {
+	// Truncate width if needed (skip for multi-line content: text, plan, thinking)
+	if line.Type != session.OutputTypeText && line.Type != session.OutputTypePlanReady && line.Type != session.OutputTypeThinking && runewidth.StringWidth(stripAnsi(formatted)) > width-2 {
 		formatted = truncateVisual(formatted, width-2)
 	}
 

bramble/cmd/codexlogview/parser.go

@@ -441,7 +441,7 @@ func (p *codexReplayParser) appendTextDelta(ts time.Time, threadID, itemID, delt
 	}
 
 	if idx, ok := p.itemTextLine[itemID]; ok && idx >= 0 && idx < len(p.lines) {
-		p.lines[idx].Content = appendStreamingDelta(p.lines[idx].Content, delta)
+		p.lines[idx].Content = session.AppendStreamingDelta(p.lines[idx].Content, delta)
 		return
 	}
 
@@ -500,7 +500,7 @@ func (p *codexReplayParser) appendOrAddText(ts time.Time, text string) {
 		return
 	}
 	if len(p.lines) > 0 && p.lines[len(p.lines)-1].Type == session.OutputTypeText {
-		p.lines[len(p.lines)-1].Content = appendStreamingDelta(p.lines[len(p.lines)-1].Content, text)
+		p.lines[len(p.lines)-1].Content = session.AppendStreamingDelta(p.lines[len(p.lines)-1].Content, text)
 		return
 	}
 	p.lines = append(p.lines, session.OutputLine{
@@ -515,7 +515,7 @@ func (p *codexReplayParser) appendOrAddThinking(ts time.Time, text string) {
 		return
 	}
 	if len(p.lines) > 0 && p.lines[len(p.lines)-1].Type == session.OutputTypeThinking {
-		p.lines[len(p.lines)-1].Content = appendStreamingDelta(p.lines[len(p.lines)-1].Content, text)
+		p.lines[len(p.lines)-1].Content = session.AppendStreamingDelta(p.lines[len(p.lines)-1].Content, text)
 		return
 	}
 	p.lines = append(p.lines, session.OutputLine{
@@ -569,27 +569,6 @@ func parseTimestamp(ts string) time.Time {
 	return time.Now()
 }
 
-// appendStreamingDelta appends a new streaming delta while removing duplicated
-// overlap between the end of the existing text and the start of the delta.
-func appendStreamingDelta(existing, delta string) string {
-	if existing == "" || delta == "" {
-		return existing + delta
-	}
-
-	maxOverlap := len(existing)
-	if len(delta) < maxOverlap {
-		maxOverlap = len(delta)
-	}
-
-	for overlap := maxOverlap; overlap > 0; overlap-- {
-		if existing[len(existing)-overlap:] == delta[:overlap] {
-			return existing + delta[overlap:]
-		}
-	}
-
-	return existing + delta
-}
-
 func tokenSummaryContent(usage codex.TokenUsage) string {
 	return fmt.Sprintf("Tokens: %d input / %d output", usage.InputTokens, usage.OutputTokens)
 }

bramble/session/event_handler.go

@@ -33,11 +33,7 @@ func (h *sessionEventHandler) OnText(text string) {
 }
 
 func (h *sessionEventHandler) OnThinking(thinking string) {
-	h.manager.addOutput(h.sessionID, OutputLine{
-		Timestamp: time.Now(),
-		Type:      OutputTypeThinking,
-		Content:   thinking,
-	})
+	h.manager.appendOrAddThinking(h.sessionID, thinking)
 }
 
 func (h *sessionEventHandler) OnToolStart(name, id string, input map[string]interface{}) {

bramble/session/manager.go

@@ -928,22 +928,24 @@ func (m *Manager) addOutput(sessionID SessionID, line OutputLine) {
 	}
 }
 
-// appendOrAddText appends text to the last output line if it's a text line,
-// otherwise adds a new text line. This allows streaming text to accumulate
-// into a single OutputLine for proper markdown rendering.
-func (m *Manager) appendOrAddText(sessionID SessionID, text string) {
+// appendOrAddOutput appends a streaming delta to the last output line if its
+// type matches, otherwise adds a new line. This allows streaming text and
+// thinking deltas to accumulate into a single OutputLine instead of creating
+// one line per delta. Plain concatenation is used because live streaming
+// deltas are non-overlapping token chunks. (For replay of protocol logs where
+// deltas may overlap, use AppendStreamingDelta instead.)
+func (m *Manager) appendOrAddOutput(sessionID SessionID, lineType OutputLineType, delta string) {
 	m.outputsMu.Lock()
 	lines, ok := m.outputs[sessionID]
-	if ok && len(lines) > 0 && lines[len(lines)-1].Type == OutputTypeText {
-		// Append to existing text line
-		lines[len(lines)-1].Content += text
+	if ok && len(lines) > 0 && lines[len(lines)-1].Type == lineType {
+		lines[len(lines)-1].Content += delta
 		m.outputsMu.Unlock()
 	} else {
 		m.outputsMu.Unlock()
 		m.addOutput(sessionID, OutputLine{
 			Timestamp: time.Now(),
-			Type:      OutputTypeText,
-			Content:   text,
+			Type:      lineType,
+			Content:   delta,
 		})
 		return
 	}
@@ -952,8 +954,21 @@ func (m *Manager) appendOrAddText(sessionID SessionID, text string) {
 	select {
 	case m.events <- SessionOutputEvent{SessionID: sessionID}:
 	default:
-		log.Printf("WARNING: events channel full, dropping text append event for session %s", sessionID)
+		log.Printf("WARNING: events channel full, dropping %s append event for session %s", lineType, sessionID)
+	}
+}
+
+// appendOrAddText appends text to the last text output line, or adds a new one.
+func (m *Manager) appendOrAddText(sessionID SessionID, text string) {
+	m.appendOrAddOutput(sessionID, OutputTypeText, text)
+}
+
+// appendOrAddThinking appends thinking to the last thinking output line, or adds a new one.
+func (m *Manager) appendOrAddThinking(sessionID SessionID, thinking string) {
+	if strings.TrimSpace(thinking) == "" {
+		return
 	}
+	m.appendOrAddOutput(sessionID, OutputTypeThinking, thinking)
 }
 
 // updateToolOutput updates an existing tool output line by ToolID.

bramble/session/types.go

@@ -286,6 +286,29 @@ func deepCopyOutputLine(line OutputLine) OutputLine {
 	return line
 }
 
+// AppendStreamingDelta appends a new streaming delta while removing duplicated
+// overlap between the end of the existing text and the start of the delta.
+// This is used to accumulate streaming text/thinking deltas into a single
+// OutputLine.Content without producing duplicate text at chunk boundaries.
+func AppendStreamingDelta(existing, delta string) string {
+	if existing == "" || delta == "" {
+		return existing + delta
+	}
+
+	maxOverlap := len(existing)
+	if len(delta) < maxOverlap {
+		maxOverlap = len(delta)
+	}
+
+	for overlap := maxOverlap; overlap > 0; overlap-- {
+		if existing[len(existing)-overlap:] == delta[:overlap] {
+			return existing + delta[overlap:]
+		}
+	}
+
+	return existing + delta
+}
+
 // SessionOutputEvent is sent when session produces output.
 type SessionOutputEvent struct {
 	SessionID SessionID