fix(tui): blinking cursor in /btw, proper idle redraws, tighter status bar

Three related tweaks to how the interactive mode drives its redraw
loop, the terminal cursor, and the status-bar layout.

1) Redraw-on-tick narrowed to things that actually animate.

   The render loop used to force a redraw every 120ms for every
   open dialog (model picker, jump, sessions, btw, etc). Most
   of those are static pickers \u2014 the repaint was wasted and had
   a visible side effect: the re-emitted hide-cursor / show-cursor
   pair at the start of each frame cancels the terminal's blink
   cycle for any dialog that hosts its own input field. Concretely
   the blinking cursor in /btw never blinked, it just sat as a
   steady reverse-video block.

   Tick-driven redraw is now only triggered when i.busy (main
   spinner animates) or btw.Loading() (side-chat spinner animates).
   Static dialogs rely on the dirty-channel invalidations that
   fire on key events, which is sufficient because nothing else
   on screen is moving.

2) btw side-chat redraws on completion.

   Consequence of (1): the btw goroutine that streams a model
   response used to depend on the 120ms tick to make the final
   answer visible. With the tick gone for idle dialogs, the
   answer landed in d.turns but the screen stayed blank until
   the user pressed a key.

   btwDialog.Open and submit now take an invalidate callback
   that the goroutine fires after completeTurn, including the
   early-error branch. While the request is in flight,
   btw.Loading() returns true so the tick keeps the spinner
   animating; once the answer lands, a single invalidate()
   redraws and the tick stops.

3) Cursor routed into btw while it's open.

   btwDialog already had a CursorPos(width) method that returns
   where the side-chat editor's caret sits within the dialog's
   rendered rows. The host never used it \u2014 the real terminal
   cursor stayed on the main editor below. Now when btw is
   active the host picks up CursorPos and points the terminal
   cursor there, so the blink shows in the correct input and
   the main editor has no cursor.

4) Status bar idle-path spacing.

   Idle row used to render as "<pad><pad>(provider) model" =
   4 spaces before the model, so the line started at column 4
   while busy and idle didn't match. Dropped one pad in the
   idle branch; both paths now start at column 2, aligned with
   the conversation column ('  you' / '  zot' message markers).

No semantic change to transcripts or provider calls. All tests
pass.

commit: 6019404644dd1d4e6779fa2a61cc138195baf1aa
author: patriceckhart · 6mo ago · 2026-04-21 16:09 UTC
parent: fc47398
signature: unsigned
refs: tag: v0.0.82

3 files · +63 -15

M internal/agent/modes/btw_dialog.go +32 -7


@@ -73,11 +73,27 @@ func (d *btwDialog) Active() bool {
73	73		return d.active
74	74		}
75	75
	76	+	// Loading reports whether the dialog is currently awaiting a
	77	+	// model response (and therefore rendering an animated spinner).
	78	+	// Used by the host to decide whether a periodic redraw is worth
	79	+	// triggering; when false and the user is just typing, we can
	80	+	// skip the tick and let the terminal drive the cursor blink.
	81	+	func (d *btwDialog) Loading() bool {
	82	+	if d == nil {
	83	+	return false
	84	+	}
	85	+	d.mu.Lock()
	86	+	defer d.mu.Unlock()
	87	+	return d.active && d.loading
	88	+	}
	89	+
76	90		// Open enters the side chat. agent supplies the live transcript and
77	91		// system prompt, plus the underlying provider client to use for the
78	92		// one-off completion. seed is an optional first question that gets
79		-	// auto-submitted (so /btw <text> behaves like the reference).
80		-	func (d btwDialog) Open(th tui.Theme, agent core.Agent, system, model, seed string) {
	93	+	// auto-submitted (so /btw <text> starts a conversation right away).
	94	+	// invalidate, if non-nil, is called after each state change so the
	95	+	// host redraw loop can pick up the update without polling.
	96	+	func (d btwDialog) Open(th tui.Theme, agent core.Agent, system, model, seed string, invalidate func()) {
81	97		d.mu.Lock()
82	98		d.active = true
83	99		d.theme = th

@@ -93,7 +109,7 @@ func (d btwDialog) Open(th tui.Theme, agent core.Agent, system, model, seed st
93	109
94	110		if seed = strings.TrimSpace(seed); seed != "" {
95	111		d.editor.SetValue(seed)
96		-	d.submit()
	112	+	d.submit(invalidate)
97	113		}
98	114		}
99	115

@@ -151,14 +167,17 @@ func (d *btwDialog) HandleKey(k tui.Key, invalidate func()) (closed bool) {
151	167		submitted := editor.HandleKey(k)
152	168		invalidate()
153	169		if submitted && !loading {
154		-	d.submit()
	170	+	d.submit(invalidate)
155	171		}
156	172		return false
157	173		}
158	174
159	175		// submit fires the LLM call for the current input and, on success,
160		-	// appends a new turn to d.turns.
161		-	func (d *btwDialog) submit() {
	176	+	// appends a new turn to d.turns. invalidate is called every time
	177	+	// the turn's visible state changes (text delta, error, complete)
	178	+	// so the host redraw loop picks up the update without relying on
	179	+	// a periodic tick.
	180	+	func (d *btwDialog) submit(invalidate func()) {
162	181		d.mu.Lock()
163	182		if d.editor == nil \|\| d.loading {
164	183		d.mu.Unlock()

@@ -219,6 +238,9 @@ func (d *btwDialog) submit() {
219	238		stream, err := client.Stream(ctx, req)
220	239		if err != nil {
221	240		d.completeTurn(turnIdx, "", err.Error())
	241	+	if invalidate != nil {
	242	+	invalidate()
	243	+	}
222	244		return
223	245		}
224	246

@@ -240,6 +262,9 @@ func (d *btwDialog) submit() {
240	262		errMsg = finalErr.Error()
241	263		}
242	264		d.completeTurn(turnIdx, reply.String(), errMsg)
	265	+	if invalidate != nil {
	266	+	invalidate()
	267	+	}
243	268		}()
244	269		}
245	270

@@ -267,7 +292,7 @@ func (d *btwDialog) Render(th tui.Theme, width int) []string {
267	292		}
268	293
269	294		var out []string
270		-	out = append(out, frameHeaderColor(th, "btw — side chat (esc closes; nothing is added to the main thread)", width, th.Accent))
	295	+	out = append(out, frameHeaderColor(th, "btw - side chat (esc closes; nothing is added to the main thread)", width, th.Accent))
271	296
272	297		if len(d.turns) == 0 && !d.loading {
273	298		out = append(out, " "+th.FG256(th.Muted, "ask anything; replies stay private to this side chat."))

 	return d.active
 }
+// Loading reports whether the dialog is currently awaiting a
+// model response (and therefore rendering an animated spinner).
+// Used by the host to decide whether a periodic redraw is worth
+// triggering; when false and the user is just typing, we can
+// skip the tick and let the terminal drive the cursor blink.
+func (d *btwDialog) Loading() bool {
+	if d == nil {
+		return false
+	}
+	d.mu.Lock()
+	defer d.mu.Unlock()
+	return d.active && d.loading
+}
 // Open enters the side chat. agent supplies the live transcript and
 // system prompt, plus the underlying provider client to use for the
 // one-off completion. seed is an optional first question that gets
-// auto-submitted (so /btw <text> behaves like the reference).
+// auto-submitted (so /btw <text> starts a conversation right away).
-func (d *btwDialog) Open(th tui.Theme, agent *core.Agent, system, model, seed string) {
+// invalidate, if non-nil, is called after each state change so the
+// host redraw loop can pick up the update without polling.
+func (d *btwDialog) Open(th tui.Theme, agent *core.Agent, system, model, seed string, invalidate func()) {
 	d.mu.Lock()
 	d.active = true
 	d.theme = th
 	if seed = strings.TrimSpace(seed); seed != "" {
 		d.editor.SetValue(seed)
-		d.submit()
+		d.submit(invalidate)
 	}
 }
 	submitted := editor.HandleKey(k)
 	invalidate()
 	if submitted && !loading {
-		d.submit()
+		d.submit(invalidate)
 	}
 	return false
 }
 // submit fires the LLM call for the current input and, on success,
-// appends a new turn to d.turns.
+// appends a new turn to d.turns. invalidate is called every time
-func (d *btwDialog) submit() {
+// the turn's visible state changes (text delta, error, complete)
+// so the host redraw loop picks up the update without relying on
+// a periodic tick.
+func (d *btwDialog) submit(invalidate func()) {
 	d.mu.Lock()
 	if d.editor == nil || d.loading {
 		d.mu.Unlock()
 		stream, err := client.Stream(ctx, req)
 		if err != nil {
 			d.completeTurn(turnIdx, "", err.Error())
+			if invalidate != nil {
+				invalidate()
+			}
 			return
 		}
 			errMsg = finalErr.Error()
 		}
 		d.completeTurn(turnIdx, reply.String(), errMsg)
+		if invalidate != nil {
+			invalidate()
+		}
 	}()
 }
 	}
 	var out []string
-	out = append(out, frameHeaderColor(th, "btw — side chat (esc closes; nothing is added to the main thread)", width, th.Accent))
+	out = append(out, frameHeaderColor(th, "btw - side chat (esc closes; nothing is added to the main thread)", width, th.Accent))
 	if len(d.turns) == 0 && !d.loading {
 		out = append(out, "  "+th.FG256(th.Muted, "ask anything; replies stay private to this side chat."))

M internal/agent/modes/interactive.go +24 -5


@@ -478,8 +478,15 @@ func (i *Interactive) Run(ctx context.Context) error {
478	478		// and the AfterFunc-driven invalidate got dropped on a
479	479		// full channel.
480	480		drainPending()
481		-	if i.busy \|\| i.dialog.Active() \|\| i.modelDialog.Active() \|\| i.sessionDialog.Active() \|\| i.jumpDialog.Active() \|\| i.btwDialog.Active() \|\| i.skillsDialog.Active() \|\| i.changelogDialog.Active() \|\| i.confirmDialog.Active() \|\| i.logoutDialog.Active() \|\| i.telegramDialog.Active() \|\| i.sessionOpsDialog.Active() \|\| i.sessionTreeDialog.Active() {
482		-	requestRedraw() // keep the spinner / dialog animation moving
	481	+	// Only force a periodic redraw when something is actually
	482	+	// animating (the main spinner during a busy turn, or the
	483	+	// btw side-chat spinner while it's awaiting a response).
	484	+	// Static pickers (model, session, jump, etc.) don't need
	485	+	// the tick and firing it cancels the terminal's cursor
	486	+	// blink inside dialogs that host their own editor (btw),
	487	+	// because each frame re-emits hide-cursor + show-cursor.
	488	+	if i.busy \|\| i.btwDialog.Loading() {
	489	+	requestRedraw()
483	490		}
484	491		}
485	492		}

@@ -755,7 +762,7 @@ func (i *Interactive) redraw() {
755	762		var queue []string
756	763		if len(i.queued) > 0 {
757	764		for _, q := range i.queued {
758		-	label := i.cfg.Theme.FG256(i.cfg.Theme.Accent, "▸ sliding in: ")
	765	+	label := i.cfg.Theme.FG256(i.cfg.Theme.Accent, "sliding in: ")
759	766		text := truncateLine(q, cols-15)
760	767		queue = append(queue, label+i.cfg.Theme.FG256(i.cfg.Theme.Muted, text))
761	768		}

@@ -822,8 +829,20 @@ func (i *Interactive) redraw() {
822	829		frame = append(frame, visibleChat...)
823	830		frame = append(frame, bottom...)
824	831
	832	+	// Default: the real terminal cursor sits on the main editor's
	833	+	// input position. When an overlay dialog has its own input
	834	+	// field (today just /btw), route the cursor there instead so
	835	+	// the blinking cursor shows where the user is actually typing.
	836	+	// Dialogs without a cursor (model picker, /help, /login, etc.)
	837	+	// return -1 and the main editor keeps the cursor.
825	838		cursorRow := len(visibleChat) + len(dialog) + len(suggest) + len(queue) + len(statusLines) + curR
826	839		cursorCol := curC
	840	+	if i.btwDialog.Active() {
	841	+	if r, c := i.btwDialog.CursorPos(cols); r >= 0 {
	842	+	cursorRow = len(visibleChat) + r
	843	+	cursorCol = c
	844	+	}
	845	+	}
827	846		i.rend.Draw(frame, cursorRow, cursorCol)
828	847		}
829	848

@@ -1716,7 +1735,7 @@ func (i *Interactive) openBtwDialog(args []string) {
1716	1735		return
1717	1736		}
1718	1737		seed := strings.TrimSpace(strings.Join(args, " "))
1719		-	i.btwDialog.Open(i.cfg.Theme, i.agent, i.agent.System, i.cfg.Model, seed)
	1738	+	i.btwDialog.Open(i.cfg.Theme, i.agent, i.agent.System, i.cfg.Model, seed, i.invalidate)
1720	1739		i.invalidate()
1721	1740		}
1722	1741

@@ -2289,7 +2308,7 @@ func (i *Interactive) handleEvent(ev core.AgentEvent) {
2289	2308		if tc, ok := i.toolCalls[e.ID]; ok {
2290	2309		tc.RawJSONBuf += e.Delta
2291	2310		// Refresh the live path as soon as it parses; used in
2292		-	// the header (▸ write /Users/pat/Desktop/demo.ts)
	2311	+	// the header (write /Users/pat/Desktop/demo.ts)
2293	2312		// while the content is still streaming.
2294	2313		if p, pok, _ := tui.ExtractPartialStringField(tc.RawJSONBuf, "path"); pok {
2295	2314		tc.LivePath = p

 			// and the AfterFunc-driven invalidate got dropped on a
 			// full channel.
 			drainPending()
-			if i.busy || i.dialog.Active() || i.modelDialog.Active() || i.sessionDialog.Active() || i.jumpDialog.Active() || i.btwDialog.Active() || i.skillsDialog.Active() || i.changelogDialog.Active() || i.confirmDialog.Active() || i.logoutDialog.Active() || i.telegramDialog.Active() || i.sessionOpsDialog.Active() || i.sessionTreeDialog.Active() {
+			// Only force a periodic redraw when something is actually
-				requestRedraw() // keep the spinner / dialog animation moving
+			// animating (the main spinner during a busy turn, or the
+			// btw side-chat spinner while it's awaiting a response).
+			// Static pickers (model, session, jump, etc.) don't need
+			// the tick and firing it cancels the terminal's cursor
+			// blink inside dialogs that host their own editor (btw),
+			// because each frame re-emits hide-cursor + show-cursor.
+			if i.busy || i.btwDialog.Loading() {
+				requestRedraw()
 			}
 		}
 	}
 	var queue []string
 	if len(i.queued) > 0 {
 		for _, q := range i.queued {
-			label := i.cfg.Theme.FG256(i.cfg.Theme.Accent, "▸ sliding in: ")
+			label := i.cfg.Theme.FG256(i.cfg.Theme.Accent, "sliding in: ")
 			text := truncateLine(q, cols-15)
 			queue = append(queue, label+i.cfg.Theme.FG256(i.cfg.Theme.Muted, text))
 		}
 	frame = append(frame, visibleChat...)
 	frame = append(frame, bottom...)
+	// Default: the real terminal cursor sits on the main editor's
+	// input position. When an overlay dialog has its own input
+	// field (today just /btw), route the cursor there instead so
+	// the blinking cursor shows where the user is actually typing.
+	// Dialogs without a cursor (model picker, /help, /login, etc.)
+	// return -1 and the main editor keeps the cursor.
 	cursorRow := len(visibleChat) + len(dialog) + len(suggest) + len(queue) + len(statusLines) + curR
 	cursorCol := curC
+	if i.btwDialog.Active() {
+		if r, c := i.btwDialog.CursorPos(cols); r >= 0 {
+			cursorRow = len(visibleChat) + r
+			cursorCol = c
+		}
+	}
 	i.rend.Draw(frame, cursorRow, cursorCol)
 }
 		return
 	}
 	seed := strings.TrimSpace(strings.Join(args, " "))
-	i.btwDialog.Open(i.cfg.Theme, i.agent, i.agent.System, i.cfg.Model, seed)
+	i.btwDialog.Open(i.cfg.Theme, i.agent, i.agent.System, i.cfg.Model, seed, i.invalidate)
 	i.invalidate()
 }
 		if tc, ok := i.toolCalls[e.ID]; ok {
 			tc.RawJSONBuf += e.Delta
 			// Refresh the live path as soon as it parses; used in
-			// the header (▸ write /Users/pat/Desktop/demo.ts)
+			// the header (write /Users/pat/Desktop/demo.ts)
 			// while the content is still streaming.
 			if p, pok, _ := tui.ExtractPartialStringField(tc.RawJSONBuf, "path"); pok {
 				tc.LivePath = p

M internal/tui/view.go +7 -3


@@ -445,7 +445,7 @@ func (v *View) renderMessage(m provider.Message, width int) []string {
445	445		// assistant prose above. The matching closing rule
446	446		// is emitted at the end of the tool-role message.
447	447		lines = append(lines, toolBlockRule(v.Theme, width))
448		-	lines = append(lines, indent+v.Theme.FG256(v.Theme.Tool, "▸ "+b.Name+" "+ShortArgs(b.Name, b.Arguments)))
	448	+	lines = append(lines, indent+v.Theme.FG256(v.Theme.Tool, ""+b.Name+" "+ShortArgs(b.Name, b.Arguments)))
449	449		}
450	450		}
451	451		case provider.RoleTool:

@@ -493,7 +493,7 @@ func (v *View) renderToolCall(tc ToolCallView, width int) []string {
493	493		if arg == "" && tc.LivePath != "" {
494	494		arg = tc.LivePath
495	495		}
496		-	head := v.Theme.FG256(v.Theme.Tool, "▸ "+tc.Name+" "+arg)
	496	+	head := v.Theme.FG256(v.Theme.Tool, ""+tc.Name+" "+arg)
497	497
498	498		// Live streaming body: pulled out of the partial JSON buffer for
499	499		// tools whose interesting content is a string field (currently

@@ -1377,10 +1377,14 @@ func StatusBar(p StatusBarParams) []string {
1377	1377		// Exactly one pad (2 spaces) between the busy segment and
1378	1378		// the provider/model block. The leading pad above covers
1379	1379		// the left indent.
	1380	+	leftBuilder.WriteString(pad)
1380	1381		} else {
	1382	+	// Idle path: a single pad of left inset so the line
	1383	+	// aligns with the conversation column on its left edge
	1384	+	// (" you" / " zot" message markers). Without the busy
	1385	+	// prefix there's no trailing separator to double-pad.
1381	1386		leftBuilder.WriteString(pad)
1382	1387		}
1383		-	leftBuilder.WriteString(pad)
1384	1388		leftBuilder.WriteString(th.FG256(th.Muted, left))
1385	1389		if middle != "" {
1386	1390		leftBuilder.WriteString(pad)

 				// assistant prose above. The matching closing rule
 				// is emitted at the end of the tool-role message.
 				lines = append(lines, toolBlockRule(v.Theme, width))
-				lines = append(lines, indent+v.Theme.FG256(v.Theme.Tool, "▸ "+b.Name+" "+ShortArgs(b.Name, b.Arguments)))
+				lines = append(lines, indent+v.Theme.FG256(v.Theme.Tool, ""+b.Name+" "+ShortArgs(b.Name, b.Arguments)))
 			}
 		}
 	case provider.RoleTool:
 	if arg == "" && tc.LivePath != "" {
 		arg = tc.LivePath
 	}
-	head := v.Theme.FG256(v.Theme.Tool, "▸ "+tc.Name+" "+arg)
+	head := v.Theme.FG256(v.Theme.Tool, ""+tc.Name+" "+arg)
 	// Live streaming body: pulled out of the partial JSON buffer for
 	// tools whose interesting content is a string field (currently
 		// Exactly one pad (2 spaces) between the busy segment and
 		// the provider/model block. The leading pad above covers
 		// the left indent.
+		leftBuilder.WriteString(pad)
 	} else {
+		// Idle path: a single pad of left inset so the line
+		// aligns with the conversation column on its left edge
+		// ("  you" / "  zot" message markers). Without the busy
+		// prefix there's no trailing separator to double-pad.
 		leftBuilder.WriteString(pad)
 	}
-	leftBuilder.WriteString(pad)
 	leftBuilder.WriteString(th.FG256(th.Muted, left))
 	if middle != "" {
 		leftBuilder.WriteString(pad)