fix(tui): keep the answer card's surface continuous under glamour spans

Glamour resets styling after every span and paints its margin fillers
with parent styles, so once a reset landed the card's background was
gone: the text rendered on the terminal's own background (gray in most
terminals) with blue surviving only in the card's padding and fill.

weaveSurface re-asserts the card background after every embedded SGR
reset in the glamour output — block-agnostic, so paragraphs, lists,
code blocks, and headings all keep the surface. The escape is derived
from what the card style itself paints (surfaceSGR), staying consistent
with the active color profile; themes without a surface (high-contrast)
no-op.

Verified with a per-line SGR-state simulation over the preview dumps:
zero printable cells inside the card fall back to the terminal default.

Author: jkyberneees

internal/tui/copyclean_test.go

@@ -164,6 +164,53 @@ func TestAnswerCard(t *testing.T) {
 	lipgloss.SetColorProfile(termenv.Ascii)
 }
 
+// TestSurfaceWeave pins the card's background continuity: glamour resets
+// styling after every span (and paints margin fillers unstyled), so the
+// card must re-assert its surface after each embedded reset — otherwise
+// the text sits on the terminal's own background and the card breaks up
+// into padding-only blue.
+func TestSurfaceWeave(t *testing.T) {
+	lipgloss.SetColorProfile(termenv.TrueColor)
+	defer lipgloss.SetColorProfile(termenv.Ascii)
+
+	// weaveSurface is the exact transformation: reset → reset + surface.
+	bg := "\x1b[48;2;16;19;26m"
+	woven := weaveSurface("\x1b[38;2;231;233;238mspan1\x1b[0m gap \x1b[38;2;231;233;238;1mspan2\x1b[0m", bg)
+	want := "\x1b[38;2;231;233;238mspan1\x1b[0m" + bg + " gap \x1b[38;2;231;233;238;1mspan2\x1b[0m" + bg
+	if woven != want {
+		t.Errorf("weave mismatch:\n got %q\nwant %q", woven, want)
+	}
+	// No surface sequence — no weaving (high-contrast stays pure text).
+	if got := weaveSurface("a\x1b[0mb", ""); got != "a\x1b[0mb" {
+		t.Errorf("empty surface must no-op, got %q", got)
+	}
+	// surfaceSGR reads the escape the style really paints — the ember-dark
+	// card's own blue — and returns nothing when a style paints none.
+	if got := surfaceSGR(themeFrom(emberDark).answerCard); got != bg {
+		t.Errorf("ember-dark surface escape = %q, want %q", got, bg)
+	}
+	if got := surfaceSGR(themeFrom(emberHighContrast).answerCard); got != "" {
+		t.Errorf("high-contrast must paint no surface, got %q", got)
+	}
+
+	// End to end: a finalized answer with glamour-style span resets keeps
+	// the surface under every gap inside the card.
+	m := newTestModel()
+	m.msgs = append(m.msgs, message{role: roleAsst,
+		rendered: "\x1b[38;2;231;233;238mspan1\x1b[0m \x1b[38;2;231;233;238;1mspan2\x1b[0m tail",
+		items:    []turnItem{{thinking: true, text: "hmm"}}})
+	out, _ := m.renderMessage(m.msgs[0], 0, 0)
+	// Every embedded reset inside the card region is followed by the
+	// surface re-assert (before the card's own line-end resets, which may
+	// legitimately trail) — count re-asserts, not blanket adjacency.
+	if n := strings.Count(out, "\x1b[0m"+bg); n < 2 {
+		t.Errorf("card re-asserts surface %d times, want >= 2:\n%q", n, out)
+	}
+	if !strings.Contains(plain(out), "span1 span2 tail") {
+		t.Errorf("weave lost answer text:\n%s", plain(out))
+	}
+}
+
 // TestAnswerTextIsThemeBright pins the answer card's text color: glamour's
 // stock dark preset paints body text ANSI-252 gray, which reads dimmed on
 // the surface card. Every theme's answer body must paint the palette's

internal/tui/styles.go

@@ -173,6 +173,37 @@ func answerGlamourStyle() ansi.StyleConfig {
 	return cfg
 }
 
+// surfaceSGR extracts the background escape a style actually paints, by
+// rendering a probe cell and reading it back. Deriving the sequence from
+// the style itself (instead of formatting the hex) keeps it consistent
+// with lipgloss's active color profile; "" when the style paints none.
+func surfaceSGR(st lipgloss.Style) string {
+	out := st.Render(" ")
+	i := strings.Index(out, "\x1b[48")
+	if i < 0 {
+		return ""
+	}
+	j := strings.IndexByte(out[i:], 'm')
+	if j < 0 {
+		return ""
+	}
+	return out[i : i+j+1]
+}
+
+// weaveSurface re-asserts the card background after every embedded SGR
+// reset in glamour output. Glamour resets styling after each span and
+// paints its margin fillers with parent styles, so span gaps and margin
+// spaces otherwise fall back to the terminal's own background — the card
+// breaks up into padding-only blue with the text sitting on bare
+// terminal. Re-asserting after each reset keeps the surface continuous
+// under every span, whatever block produced it.
+func weaveSurface(s, bgSeq string) string {
+	if bgSeq == "" {
+		return s
+	}
+	return strings.ReplaceAll(s, "\x1b[0m", "\x1b[0m"+bgSeq)
+}
+
 // Layout — fixed heights for the chrome around the scrollable transcript.
 const (
 	headerHeight = 2 // cockpit bar + hairline rule

internal/tui/view.go

@@ -503,7 +503,11 @@ func (m *Model) renderMessage(msg message, msgIdx, lineOffset int) (string, []st
 			if th.answerCard.GetBackground() == nil {
 				out.WriteString(content)
 			} else {
-				out.WriteString(th.answerCard.Width(m.vp.Width - 2).Render(content))
+				// Glamour resets styling after each span; without re-asserting
+				// the surface after every reset, the text would sit on the
+				// terminal's own background instead of the card.
+				card := th.answerCard.Width(m.vp.Width - 2)
+				out.WriteString(card.Render(weaveSurface(content, surfaceSGR(th.answerCard))))
 			}
 		}
 		return out.String(), refs