Improve parsing-line spinner with 20-color flowing wave

Add a dedicated wave phase that cycles through 20 hues across the
compass glyph, verb label, and typing dots. Restore the default hawk
spinner (◐◓◑◒) and simplify the status hint to "(esc stop)".

Author: Patel230

cmd/braille_spinner.go

@@ -13,6 +13,7 @@ const (
 	SpinnerBraille     SpinnerStyle = "braille"
 	SpinnerBrailleWave SpinnerStyle = "braillewave"
 	SpinnerHawk        SpinnerStyle = "hawk"
+	SpinnerHawkQuad    SpinnerStyle = "hawkquad"
 	SpinnerDNA         SpinnerStyle = "dna"
 	SpinnerScan        SpinnerStyle = "scan"
 	SpinnerPulse       SpinnerStyle = "pulse"
@@ -23,7 +24,10 @@ const (
 	SpinnerRandom      SpinnerStyle = "random"
 )
 
-// hawkQuadBlockGlyphs is the unicode.framer.website QUADBLOCK spinner (4 frames).
+// hawkSpinnerGlyphs is the default TUI spinner — partial-circle compass (smooth, readable).
+var hawkSpinnerGlyphs = []string{"◐", "◓", "◑", "◒"}
+
+// hawkQuadBlockGlyphs is the legacy QUADBLOCK animation (kept for tests / bubbles compat).
 var hawkQuadBlockGlyphs = []string{"▛", "▜", "▟", "▙"}
 
 // hawkSpinnerBG is the chat viewport background (chat_view.go).
@@ -33,7 +37,8 @@ var hawkSpinnerBG = [3]int{30, 30, 40}
 var spinnerFrames = map[SpinnerStyle][]string{
 	SpinnerBraille:     {"⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"},
 	SpinnerBrailleWave: {"⠁⠂⠄⡀", "⠂⠄⡀⢀", "⠄⡀⢀⠠", "⡀⢀⠠⠐", "⢀⠠⠐⠈", "⠠⠐⠈⠁", "⠐⠈⠁⠂", "⠈⠁⠂⠄"},
-	SpinnerHawk:        hawkQuadBlockGlyphs,
+	SpinnerHawk:        hawkSpinnerGlyphs,
+	SpinnerHawkQuad:    hawkQuadBlockGlyphs,
 	SpinnerDNA:         {"⠋⠉⠙⠚", "⠉⠙⠚⠒", "⠙⠚⠒⠂", "⠚⠒⠂⠂", "⠒⠂⠂⠒", "⠂⠂⠒⠲", "⠂⠒⠲⠴", "⠒⠲⠴⠤", "⠲⠴⠤⠄", "⠴⠤⠄⠋", "⠤⠄⠋⠉", "⠄⠋⠉⠙"},
 	SpinnerScan:        {"⡇⠀⠀⠀", "⣿⠀⠀⠀", "⢸⡇⠀⠀", "⠀⣿⠀⠀", "⠀⢸⡇⠀", "⠀⠀⣿⠀", "⠀⠀⢸⡇", "⠀⠀⠀⣿", "⠀⠀⠀⢸", "⠀⠀⠀⠀"},
 	SpinnerPulse:       {"⠀", "⠄", "⠆", "⠇", "⡇", "⣇", "⣧", "⣷", "⣿", "⣷", "⣧", "⣇", "⡇", "⠇", "⠆", "⠄"},
@@ -46,29 +51,18 @@ var spinnerFrames = map[SpinnerStyle][]string{
 // hawkTypingDots is the number of trailing typing-indicator dots.
 const hawkTypingDots = 3
 
-// colorSpinnerGlyph renders a single glyph in hawk brand orange — the
-// spinner is the visual hero of the line and the brand color. The ANSI
-// escape constants (ansiOrange, ansiReset, etc.) and the icon glyphs
-// (iconDotFilled, iconDotEmpty) live in theme.go so the entire palette
-// is editable from one place.
-func colorSpinnerGlyph(glyph string) string {
-	if glyph == "" {
-		return ""
-	}
-	return ansiOrange + glyph + ansiReset
-}
-
-// BrailleSpinner renders animated spinners with a single accent color
-// (cyan) for both the glyph and the label.
+// BrailleSpinner renders the glyph frame (◐◓◑◒) and a 20-color wave on the
+// whole status strip: glyph → verb → ▪▫▫.
 type BrailleSpinner struct {
-	mu      sync.Mutex
-	style   SpinnerStyle
-	frames  []string
-	frame   int
-	text    string
-	dots    int // 0..hawkTypingDots-1 — position of the highlighted dot
-	running bool
-	stopCh  chan struct{}
+	mu        sync.Mutex
+	style     SpinnerStyle
+	frames    []string
+	frame     int // glyph animation frame (mod len(frames))
+	wavePhase int // 0..19 flowing color wave (glyph + verb + dots)
+	text      string
+	dots      int // 0..hawkTypingDots-1 — position of the highlighted dot
+	running   bool
+	stopCh    chan struct{}
 }
 
 // NewBrailleSpinner creates a spinner with the given style and label text.
@@ -96,63 +90,23 @@ func (s *BrailleSpinner) SetLabel(text string) {
 	s.text = text
 }
 
-// SetWave is kept for backwards compatibility with existing call sites —
-// the line no longer uses a color wave so this is a no-op.
-func (s *BrailleSpinner) SetWave(_ bool) {
-	s.mu.Lock()
-	defer s.mu.Unlock()
-}
-
-func (s *BrailleSpinner) renderGlyphLocked(glyph string) string {
-	return colorSpinnerGlyph(glyph)
-}
+// SetWave is kept for backwards compatibility with existing call sites.
+// The verb and typing dots always use the 20-color wave; this is a no-op.
+func (s *BrailleSpinner) SetWave(_ bool) {}
 
-// renderLabelLocked returns the label in green followed by the trailing
-// animated dots (one yellow dot, two dim dots). The whole group is the
-// "alive" part of the spinner line.
-func (s *BrailleSpinner) renderLabelLocked() string {
-	if s.text == "" {
-		return ""
-	}
-	out := ansiGreen + s.text + ansiReset
-	out += " " + s.renderAnimatedDotsLocked()
-	return out
-}
-
-// renderAnimatedDotsLocked returns hawkTypingDots plain circles, with the
-// current position rendered in yellow and the rest dim. The filled and
-// empty glyphs come from theme.go (iconDotFilled / iconDotEmpty) so they
-// stay in sync with the rest of the TUI.
-func (s *BrailleSpinner) renderAnimatedDotsLocked() string {
-	idx := s.dots % hawkTypingDots
-	out := ""
-	for i := 0; i < hawkTypingDots; i++ {
-		if i == idx {
-			out += ansiYellow + iconDotFilled + ansiReset
-		} else {
-			out += ansiDim + iconDotEmpty + ansiReset
-		}
-	}
-	return out
-}
-
-// Frame returns the current rendered frame (spinner + label).
+// Frame returns the current rendered frame (glyph + verb + dots, all in the wave).
 func (s *BrailleSpinner) Frame() string {
 	s.mu.Lock()
 	defer s.mu.Unlock()
 	glyph := s.frames[s.frame%len(s.frames)]
-	spinner := s.renderGlyphLocked(glyph)
-	label := s.renderLabelLocked()
-	if label == "" {
-		return spinner
-	}
-	return spinner + "  " + label
+	return renderSpinnerWaveLine(glyph, s.text, s.wavePhase, s.dots)
 }
 
 // Tick advances to the next frame and cycles the dot highlight.
 func (s *BrailleSpinner) Tick() string {
 	s.mu.Lock()
 	s.frame++
+	s.wavePhase = (s.wavePhase + 1) % spinnerWaveLen
 	s.dots = (s.dots + 1) % hawkTypingDots
 	s.mu.Unlock()
 	return s.Frame()

cmd/braille_spinner_test.go

@@ -12,17 +12,16 @@ func TestBrailleSpinner_Tick(t *testing.T) {
 	if f1 == f2 {
 		t.Error("expected different frames after tick")
 	}
-	// Glyph is hawk brand orange.
-	if !strings.Contains(f1, ansiOrange) {
-		t.Error("expected orange spinner glyph")
+	// Glyph uses the 20-color wave (not fixed orange).
+	if !frameContainsSpinnerWave(f1) {
+		t.Error("expected wave-colored spinner glyph")
 	}
-	// Label is bright green.
-	if !strings.Contains(f1, ansiGreen) {
-		t.Error("expected green verb label")
+	// Verb + dots use the 20-color wave palette.
+	if !frameContainsSpinnerWave(f1) {
+		t.Error("expected wave-colored verb label")
 	}
-	// Filled dot is bright yellow.
-	if !strings.Contains(f1, ansiYellow) {
-		t.Error("expected yellow filled dot")
+	if !strings.Contains(f1, iconDotFilled) {
+		t.Error("expected filled typing dot")
 	}
 }
 
@@ -49,31 +48,38 @@ func TestBrailleSpinner_Random(t *testing.T) {
 	}
 }
 
-func TestHawkQuadBlock_Frames(t *testing.T) {
-	if len(hawkQuadBlockGlyphs) != 4 {
-		t.Fatalf("expected 4 QuadBlock glyphs, got %d", len(hawkQuadBlockGlyphs))
+func TestHawkSpinner_Frames(t *testing.T) {
+	if len(hawkSpinnerGlyphs) != 4 {
+		t.Fatalf("expected 4 compass glyphs, got %d", len(hawkSpinnerGlyphs))
 	}
-	if hawkQuadBlockGlyphs[3] != "▙" {
-		t.Fatalf("expected last QuadBlock frame ▙, got %q", hawkQuadBlockGlyphs[3])
+	if hawkSpinnerGlyphs[0] != "◐" {
+		t.Fatalf("expected first compass frame ◐, got %q", hawkSpinnerGlyphs[0])
 	}
 	s := NewBrailleSpinner(SpinnerHawk, "Working")
 	f0 := s.Frame()
-	if !strings.Contains(f0, "▛") {
-		t.Fatalf("expected QuadBlock glyph, got %q", f0)
+	if !strings.Contains(f0, "◐") {
+		t.Fatalf("expected compass glyph, got %q", f0)
 	}
 	s.Tick()
 	s.Tick()
 	s.Tick()
-	if !strings.Contains(s.Frame(), "▙") {
-		t.Fatalf("expected frame cycle to reach ▙, got %q", s.Frame())
+	if !strings.Contains(s.Frame(), "◒") {
+		t.Fatalf("expected frame cycle to reach ◒, got %q", s.Frame())
+	}
+}
+
+func TestHawkQuadBlock_LegacyFrames(t *testing.T) {
+	s := NewBrailleSpinner(SpinnerHawkQuad, "Working")
+	if !strings.Contains(s.Frame(), "▛") {
+		t.Fatalf("expected QuadBlock glyph, got %q", s.Frame())
 	}
 }
 
 func TestHawkAnimatedDots_PresentInFrame(t *testing.T) {
 	s := NewBrailleSpinner(SpinnerHawk, "Crafting")
 	f := s.Frame()
-	// Three plain circles ride after the verb: one bold cyan, two dim.
-	total := strings.Count(f, "●") + strings.Count(f, "○")
+	// Three progress dots ride after the verb: one bright, two dim.
+	total := strings.Count(f, iconDotFilled) + strings.Count(f, iconDotEmpty)
 	if total != hawkTypingDots {
 		t.Errorf("expected %d trailing circle-dots, got %d in %q", hawkTypingDots, total, f)
 	}

cmd/chat.go

@@ -286,7 +286,6 @@ func newChatModel(ref *progRef, systemPrompt string, settings hawkconfig.Setting
 	m.modeManager = shellmode.NewModeManager()
 	m.modeManager.LoadPersistedMode()
 	m.brailleSpinner = NewBrailleSpinner(SpinnerHawk, "")
-	m.brailleSpinner.SetWave(true)
 	m.brailleSpinner.SetLabel(m.spinnerVerb)
 
 	// Initialize BMAD/Aeon features

cmd/chat_model.go

@@ -55,12 +55,11 @@ var (
 	toolColor  = toolGold
 )
 
-// hawkSpinnerFrames uses plain QuadBlock glyphs for the compact bubbles spinner.
-var hawkSpinnerFrames = hawkQuadBlockGlyphs
+// hawkSpinnerFrames feeds the bubbles spinner (matches BrailleSpinner default).
+var hawkSpinnerFrames = hawkSpinnerGlyphs
 
-// hawkSpinnerFrameInterval — QuadBlock frame cadence (slightly slower
-// than the original 70ms for a calmer feel).
-const hawkSpinnerFrameInterval = 100 * time.Millisecond
+// hawkSpinnerFrameInterval — compass frame cadence.
+const hawkSpinnerFrameInterval = 80 * time.Millisecond
 
 // Spinner verbs (from hawk-archive) — picked randomly per session
 var spinnerVerbs = []string{

cmd/chat_view.go

@@ -386,20 +386,7 @@ func (m *chatModel) updateViewportContent() {
 			chatContent.WriteString(hawkC + iconAssistantPrefix + " " + rst + renderMarkdown(partial, viewWidth-3))
 			chatContent.WriteString("\n\n")
 		} else {
-			// Hawk-native spinner line: brand-orange glyph + green verb
-			// + yellow dot indicator, then ◆ blue time ◆ magenta ↓ / cyan
-			// ↑ ◆ dim hint. The ◆ separator is bright white so it stands
-			// out as a structural divider; the hint stays dim so it
-			// doesn't compete with the data.
-			elapsed := m.spinnerElapsed()
-			sep := ansiWhite + iconSeparator + ansiReset
-			hint := dimStyle.Render("(Press ESC to stop)")
-			timeStr := ansiBlue + fmt.Sprintf("%.1fs", elapsed.Seconds()) + ansiReset
-			spinnerLine := m.brailleSpinner.Frame()
-			spinnerLine += "  " + sep + "  " + timeStr
-			spinnerLine += "  " + sep + "  " + m.renderTokenCounters()
-			spinnerLine += "  " + sep + "  " + hint
-			chatContent.WriteString(spinnerLine + "\n\n")
+			chatContent.WriteString(m.renderWaitingSpinnerLine() + "\n\n")
 		}
 	}
 
@@ -612,6 +599,21 @@ func renderReflectionBox(reflection string, width int) string {
 	return border.Render(strings.TrimRight(b.String(), "\n"))
 }
 
+// renderWaitingSpinnerLine is the live status strip while the model works.
+func (m chatModel) renderWaitingSpinnerLine() string {
+	sep := ansiDim + " " + iconSpinnerSep + " " + ansiReset
+
+	var b strings.Builder
+	b.WriteString(m.brailleSpinner.Frame())
+	b.WriteString(sep)
+	b.WriteString(ansiTeal + fmt.Sprintf("%.1fs", m.spinnerElapsed().Seconds()) + ansiReset)
+	b.WriteString(sep)
+	b.WriteString(m.renderTokenCounters())
+	b.WriteString(" ")
+	b.WriteString(ansiDim + "(esc stop)" + ansiReset)
+	return b.String()
+}
+
 // renderTokenCounters formats the live per-turn token counters that ride
 // next to the spinner. Uses ↑ for input (prompt) and ↓ for output
 // (completion) tokens. The displayed numbers are lerped each render
@@ -627,13 +629,13 @@ func (m *chatModel) renderTokenCounters() string {
 	outTok := int(m.displayOutTok + 0.5)
 
 	var b strings.Builder
+	b.WriteString(ansiMagenta + ansiBold + "↓" + ansiReset)
 	b.WriteString(ansiMagenta)
-	b.WriteString("↓ ")
 	b.WriteString(formatHawkTokenCount(outTok))
 	b.WriteString(ansiReset)
-	b.WriteString(dimStyle.Render(" "))
+	b.WriteString(ansiDim + "  " + ansiReset)
+	b.WriteString(ansiCyan + ansiBold + "↑" + ansiReset)
 	b.WriteString(ansiCyan)
-	b.WriteString("↑ ")
 	b.WriteString(formatHawkTokenCount(inTok))
 	b.WriteString(ansiReset)
 	return b.String()