tweak(tui): stable spinner phrase per turn

The status-bar quip used to rotate every 2.5s through
funnyWorkingLines while a turn ran. On a long response that
meant five or six different phrases during one reply, which
reads as activity that isn't actually happening (the model is
just still streaming the same answer).

Start() now picks a random index once, Message() returns that
same index until the next Start(). Next turn picks a different
phrase so the set still feels varied across a session.

Dropped the unused lastSwap timer field that drove the rotation
and its assignments in Start/StartFixed.

commit: e1fdf4d42e741d2ec43bc68c7526567fda82ac68
author: patriceckhart · 6mo ago · 2026-04-20 14:00 UTC
parent: 8927ac1
signature: unsigned
refs: tag: v0.0.68

1 file · +11 -12

M internal/agent/modes/spinner.go +11 -12


@@ -13,7 +13,6 @@ type spinner struct {
13	13		messages []string
14	14		startedAt time.Time
15	15		msgIdx int
16		-	lastSwap time.Time
17	16
18	17		// fixedMsg overrides the rotating funnyWorkingLines message when
19	18		// set. Used for auto-compaction so the spinner clearly says what's

@@ -80,12 +79,17 @@ func newSpinner() *spinner {
80	79		return s
81	80		}
82	81
83		-	// Start resets the spinner to the beginning of its animation and picks
84		-	// a random opening message.
	82	+	// Start resets the spinner to the beginning of its animation and
	83	+	// picks a random message that stays fixed for the whole run. A
	84	+	// rotating rollodex of quips during a single turn felt noisy in
	85	+	// practice — you'd see five different phrases for one
	86	+	// long-running response, which implies progress that isn't
	87	+	// actually happening. One stable phrase per turn reads calmer
	88	+	// and the variety across turns (next Start picks another index)
	89	+	// still keeps the set fresh over a session.
85	90		func (s *spinner) Start() {
86	91		s.startedAt = time.Now()
87	92		s.msgIdx = rand.Intn(len(s.messages))
88		-	s.lastSwap = s.startedAt
89	93		s.fixedMsg = ""
90	94		}
91	95

@@ -93,7 +97,6 @@ func (s *spinner) Start() {
93	97		// duration of this spinner run. Cleared by the next Start() call.
94	98		func (s *spinner) StartFixed(msg string) {
95	99		s.startedAt = time.Now()
96		-	s.lastSwap = s.startedAt
97	100		s.fixedMsg = msg
98	101		}
99	102

@@ -109,18 +112,14 @@ func (s *spinner) Frame() string {
109	112		return s.frames[idx]
110	113		}
111	114
112		-	// Message returns the current rotating status text. The text changes
113		-	// every ~2.5 seconds so the spinner doesn't look frozen. When the
114		-	// spinner was started via StartFixed, the pinned message is returned
	115	+	// Message returns the spinner's status text. One random phrase
	116	+	// per Start call, pinned until the next turn. When the spinner
	117	+	// was started via StartFixed, the pinned message is returned
115	118		// unchanged.
116	119		func (s *spinner) Message() string {
117	120		if s.fixedMsg != "" {
118	121		return s.fixedMsg
119	122		}
120		-	if time.Since(s.lastSwap) > 2500*time.Millisecond {
121		-	s.msgIdx = (s.msgIdx + 1) % len(s.messages)
122		-	s.lastSwap = time.Now()
123		-	}
124	123		return s.messages[s.msgIdx]
125	124		}
126	125

 	messages  []string
 	startedAt time.Time
 	msgIdx    int
-	lastSwap  time.Time
 	// fixedMsg overrides the rotating funnyWorkingLines message when
 	// set. Used for auto-compaction so the spinner clearly says what's
 	return s
 }
-// Start resets the spinner to the beginning of its animation and picks
+// Start resets the spinner to the beginning of its animation and
-// a random opening message.
+// picks a random message that stays fixed for the whole run. A
+// rotating rollodex of quips during a single turn felt noisy in
+// practice — you'd see five different phrases for one
+// long-running response, which implies progress that isn't
+// actually happening. One stable phrase per turn reads calmer
+// and the variety across turns (next Start picks another index)
+// still keeps the set fresh over a session.
 func (s *spinner) Start() {
 	s.startedAt = time.Now()
 	s.msgIdx = rand.Intn(len(s.messages))
-	s.lastSwap = s.startedAt
 	s.fixedMsg = ""
 }
 // duration of this spinner run. Cleared by the next Start() call.
 func (s *spinner) StartFixed(msg string) {
 	s.startedAt = time.Now()
-	s.lastSwap = s.startedAt
 	s.fixedMsg = msg
 }
 	return s.frames[idx]
 }
-// Message returns the current rotating status text. The text changes
+// Message returns the spinner's status text. One random phrase
-// every ~2.5 seconds so the spinner doesn't look frozen. When the
+// per Start call, pinned until the next turn. When the spinner
-// spinner was started via StartFixed, the pinned message is returned
+// was started via StartFixed, the pinned message is returned
 // unchanged.
 func (s *spinner) Message() string {
 	if s.fixedMsg != "" {
 		return s.fixedMsg
 	}
-	if time.Since(s.lastSwap) > 2500*time.Millisecond {
-		s.msgIdx = (s.msgIdx + 1) % len(s.messages)
-		s.lastSwap = time.Now()
-	}
 	return s.messages[s.msgIdx]
 }