johannSoCodeyPublic

tui: the mouse scrolls, selects and copies

The TUI runs in the alternate screen, where the terminal has no
scrollback of its own to roll, and it never asked for mouse reporting —
so the wheel did nothing at all, and a drag was the terminal's business
and reached nothing here.

Asking for mouse reporting fixes the wheel and breaks the drag: the
moment a program takes the mouse, the terminal stops sending drags to
its own selection. So the selection had to be replaced rather than
merely gained. Drag marks text and copies it when you let go;
double-click takes a word, triple-click a line, shift+click extends. A
word is a run of path characters too, because what is worth
double-clicking in a wall of tool output is internal/tui/model.go:222
and not "internal". Dragging against either edge scrolls, which keeps
going while the pointer moves — button-event reporting says nothing
about a hand held still, and a ticker that scrolled on its own would run
away from a hand that had stopped.

Clicking is answering: a completion row, a model, the slider's track or
labels, an approval choice, the mode line. Each goes through the same
setter its key does, so a click and an enter cannot decide differently.
The wheel over an open list moves through it rather than rolling the
transcript behind it.

The chrome is now assembled from layout(), a list of sections, and
bottom() joins that same list — a click resolves against the rows the
frame actually drew rather than against a second copy of the height
arithmetic, which is the way that sort of thing drifts.

A selection is content lines and display cells, not screen cells, so it
survives scrolling and a streaming turn appending underneath it; a
resize, ctrl+r or the wizard drops it, because those lay every line out
again. It is painted over the viewport's own output — the visible rows
only, so the transcript's render cache is untouched on the path a
streamed token takes — and the marked span is stripped before it is
restyled, because a style nested inside a background ends in a reset and
would tear a hole across a line of highlighted code.

Copying goes out twice, over OSC 52 and to the desktop clipboard,
because neither works everywhere: OSC 52 is the only one that survives
ssh, and several terminals ship with it disabled. What was copied is
reported on the activity line, where five copies cost no scrollback; a
failure is reported in the transcript, where it cannot be missed.

/mouse hands the mouse back to the terminal. Clicking in the prompt box
does not move the caret: bubbles' textarea has no mouse of its own and
soft-wrapped lines make placing one fiddly, so the prompt stays
keyboard-driven and the README says so.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Browse Files

Jjonicommitted 4 weeks ago1 parent e9e6141commit00e7e95

Showing 16 changed files with 1700 additions and 67 deletions.

+28−1README.mdView File

@@ -137,7 +137,34 @@ to six lines.
137	137	\| `ctrl+c` \| interrupt the turn; again when idle to exit \|
138	138
139	139	Commands: `/allowed`, `/clear`, `/effort`, `/exit`, `/help`, `/model`,
140		- `/setup`, `/skills`, and one per discovered skill.
	140	+ `/mouse`, `/setup`, `/skills`, and one per discovered skill.
	141	+
	142	+ ### The mouse
	143	+
	144	+ \| Does \| How \|
	145	+ \| --- \| --- \|
	146	+ \| scroll the transcript \| the wheel, anywhere \|
	147	+ \| select \| drag; double-click a word, triple-click a line, shift+click to extend \|
	148	+ \| copy \| let go — the selection lands on the clipboard on release \|
	149	+ \| choose \| click a menu row, a model, the effort slider, an approval, the mode line \|
	150	+
	151	+ The prompt box is keyboard-driven: a click does not move the caret in it, and
	152	+ what you have typed is the one thing the mouse cannot select. Dragging against
	153	+ the top or bottom edge of the transcript scrolls, so a selection can be longer
	154	+ than the screen; it keeps going while the pointer moves, because a terminal
	155	+ reporting button events says nothing about a hand held still.
	156	+
	157	+ The harness runs in the alternate screen, where the terminal has no scrollback
	158	+ of its own to roll — so asking for mouse reporting is what makes the wheel work
	159	+ at all. The cost is the terminal's own text selection, which stops being the
	160	+ terminal's the moment drags are reported to the program. That is why the
	161	+ selection above exists: it is the replacement, and copying goes out over both
	162	+ OSC 52 (which works over ssh) and the desktop clipboard, because terminals
	163	+ disagree about which of the two they allow.
	164	+
	165	+ `/mouse` hands the mouse back. Selection and copy become the terminal's again,
	166	+ exactly as before this existed, and the wheel goes quiet. `shift`+drag usually
	167	+ reaches the terminal's own selection without turning reporting off at all.
141	168
142	169	A slash at the start of an empty prompt opens the command menu, which filters
143	170	as you type — a name that starts with what you typed before one that merely

+1−1go.modView File

@@ -4,6 +4,7 @@ go 1.26.8
4	4
5	5	require (
6	6	github.com/alecthomas/chroma/v2 v2.20.0
	7	+ github.com/atotto/clipboard v0.1.4
7	8	github.com/bmatcuk/doublestar/v4 v4.10.0
8	9	github.com/charmbracelet/bubbles v1.0.0
9	10	github.com/charmbracelet/bubbletea v1.3.10
@@ -17,7 +18,6 @@ require (
17	18	)
18	19
19	20	require (
20		- github.com/atotto/clipboard v0.1.4 // indirect
21	21	github.com/aymanbagabas/go-osc52/v2 v2.0.1 // indirect
22	22	github.com/aymerick/douceur v0.2.0 // indirect
23	23	github.com/bahlo/generic-list-go v0.2.0 // indirect

+76−0internal/tui/clipboard.goaddedView File

++ package tui
++ import (
++ 	"os"
++ 	"strconv"
++ 	"strings"
++ 	"github.com/atotto/clipboard"
++ 	tea "github.com/charmbracelet/bubbletea"
++ 	"github.com/charmbracelet/x/ansi"
++ )
++ // Copying out of a full-screen terminal program is done twice, because
++ // neither way works everywhere.
++ //
++ // OSC 52 asks the terminal itself to take the text, which is the only way
++ // that works over ssh, in a container, or anywhere else the process is not
++ // sitting next to the desktop it is displayed on. Several terminals ship with
++ // it turned off, though, so the desktop's own clipboard is written too, with
++ // the same bytes — whichever of the two lands, the text is the text.
++ //
++ // The OSC 52 sequence is written straight to the terminal rather than through
++ // a frame. It carries no cursor movement and ends itself, so landing between
++ // two frames costs nothing on screen.
++ // copyMax caps what is sent. Terminals have their own limit on an OSC 52
++ // payload — commonly around 100k after base64 — and a selection large enough
++ // to hit it is a mis-drag rather than something a person means to paste.
++ const copyMax = 64 * 1024
++ // copiedMsg reports a finished copy. The text comes back with it so the
++ // chrome can say what was taken without reaching for the selection again,
++ // which by then may already be gone.
++ type copiedMsg struct {
++ 	text string
++ 	err  error
++ }
++ func copyToClipboard(text string) error {
++ 	if text == "" {
++ 		return nil
++ 	}
++ 	if len(text) > copyMax {
++ 		text = text[:copyMax]
++ 	}
++ 	// The desktop clipboard is best effort: no X display, no xclip, no
++ 	// pbcopy — all of them are ordinary on a remote machine, and none of them
++ 	// means the copy failed, because OSC 52 is still on its way.
++ 	_ = clipboard.WriteAll(text)
++ 	_, err := os.Stdout.WriteString(ansi.SetSystemClipboard(text))
++ 	return err
++ }
++ // finishCopy is what the chrome says about it. A failure is worth a line in
++ // the transcript — the text is not on the clipboard and the person is about
++ // to try to paste it — but a success is not: it belongs on the status line,
++ // where it costs no scrollback.
++ func (m *model) finishCopy(msg copiedMsg) tea.Cmd {
++ 	if msg.err != nil {
++ 		m.tr.addError("could not copy: " + msg.err.Error())
++ 		return m.sync()
++ 	}
++ 	m.copied = "✂ " + copyNote(msg.text)
++ 	return nil
++ }
++ // copyNote says what was taken. One line is quoted back, because seeing the
++ // words is the fastest way to know the right thing was caught; more than one
++ // is counted, because a quote would not fit.
++ func copyNote(text string) string {
++ 	if n := strings.Count(text, "\n"); n > 0 {
++ 		return "copied " + plural(n+1, "line")
++ 	}
++ 	return "copied " + strconv.Quote(truncate(text, 28))
++ }

+8−3internal/tui/colour_test.goView File

@@ -22,8 +22,13 @@ func forceColour(t *testing.T) {
22	22	}
23	23
24	24	// unbackedCells returns the printable characters that were emitted with no
25		- // background colour in force.
26		- func unbackedCells(s string) string {
	25	+ // background colour in force, and backedCells the ones that had one. Between
	26	+ // them they say where a background actually landed: which cells a pill filled,
	27	+ // and which cells a mouse selection marked.
	28	+ func unbackedCells(s string) string { return cellsWithBackground(s, false) }
	29	+ func backedCells(s string) string { return cellsWithBackground(s, true) }
	30	+
	31	+ func cellsWithBackground(s string, want bool) string {
27	32	var out []rune
28	33	active := ""
29	34	for i := 0; i < len(s); {
@@ -44,7 +49,7 @@ func unbackedCells(s string) string {
44	49	continue
45	50	}
46	51	r, size := utf8.DecodeRuneInString(s[i:])
47		- if !strings.Contains(active, "48;") {
	52	+ if strings.Contains(active, "48;") == want {
48	53	out = append(out, r)
49	54	}
50	55	i += size

+6−1internal/tui/commands.goView File

@@ -27,6 +27,7 @@ var builtins = []command{
27	27	{name: "effort", args: "level", desc: "how hard the model thinks — opens a slider"},
28	28	{name: "setup", desc: "the full-screen wizard for the saved defaults"},
29	29	{name: "clear", desc: "empty the transcript"},
	30	+ {name: "mouse", desc: "hand the mouse back to the terminal, or take it again"},
30	31	{name: "allowed", desc: "what is permanently allowed this session"},
31	32	{name: "exit", desc: "leave the harness"},
32	33	}
@@ -78,7 +79,11 @@ func (m *model) helpText() string {
78	79	if n := len(m.opts.Skills); n > 0 {
79	80	fmt.Fprintf(&b, "\n %-18s %s", "/<skill>", plural(n, "discovered skill")+" — /skills lists them")
80	81	}
81		- b.WriteString("\nkeys: enter send · ctrl+j newline · shift+tab cycle approval mode" +
	82	+ b.WriteString("\nmouse: wheel scrolls · drag selects and copies on release" +
	83	+ "\n double-click a word · triple-click a line · shift+click extends" +
	84	+ "\n click a menu row, a model, the slider or an approval to choose it" +
	85	+ "\n /mouse hands the mouse back to the terminal for its own selection" +
	86	+ "\nkeys: enter send · ctrl+j newline · shift+tab cycle approval mode" +
82	87	"\n ! runs a shell command · $ runs python — both on an empty prompt" +
83	88	"\n what they print goes to the agent too, so you can then say \"fix that\"" +
84	89	"\n / opens the command menu · ↑↓ move · tab or enter complete · esc dismiss" +

+17−11internal/tui/complete.goView File

@@ -123,17 +123,7 @@ func (m *model) menuView() string {
123	123	if !m.menuOpen() {
124	124	return ""
125	125	}
126		- rows := m.menuRows()
127		- shown := rows
128		- if len(m.menu.items) > rows {
129		- // The last row goes to the count of what did not fit.
130		- shown = maxInt(1, rows-1)
131		- }
132		- start := 0
133		- if m.menu.idx >= shown {
134		- start = m.menu.idx - shown + 1
135		- }
136		- end := minInt(len(m.menu.items), start+shown)
	126	+ start, end := m.menuWindow()
137	127
138	128	// One column for the names, so the descriptions line up. A long skill
139	129	// name is left to overflow its column rather than being truncated: the
@@ -166,6 +156,22 @@ func (m *model) menuView() string {
166	156	return strings.TrimRight(b.String(), "\n")
167	157	}
168	158
	159	+ // menuWindow is the slice of the list that is on screen. The view draws it
	160	+ // and a click is resolved against it, so the row under the pointer and the
	161	+ // row that was drawn are the same row by construction.
	162	+ func (m *model) menuWindow() (start, end int) {
	163	+ rows := m.menuRows()
	164	+ shown := rows
	165	+ if len(m.menu.items) > rows {
	166	+ // The last row goes to the count of what did not fit.
	167	+ shown = maxInt(1, rows-1)
	168	+ }
	169	+ if m.menu.idx >= shown {
	170	+ start = m.menu.idx - shown + 1
	171	+ }
	172	+ return start, minInt(len(m.menu.items), start+shown)
	173	+ }
	174	+
169	175	// pad widens s to width cells, leaving anything already wider alone.
170	176	func pad(s string, width int) string {
171	177	if n := width - lipgloss.Width(s); n > 0 {

+42−0internal/tui/effort.goView File

@@ -94,6 +94,16 @@ func (m *model) applyEffort(level string) {
94	94	m.tr.addNotice("effort: " + level + " — from the next turn on")
95	95	}
96	96
	97	+ // The slider's four rows. Two of them are the slider — the track and the
	98	+ // labels under it — and two are words about it, which is the difference
	99	+ // between a click that moves the marker and a click on a caption.
	100	+ const (
	101	+ effortPoleRow = iota
	102	+ effortTrackRow
	103	+ effortLabelRow
	104	+ effortKeysRow
	105	+ )
	106	+
97	107	// effortView is the slider: the poles, the track with the marker riding it,
98	108	// the labels under it, and the keys that drive it.
99	109	//
@@ -138,6 +148,38 @@ func (m *model) effortView() string {
138	148	truncateStyled(" "+styFaint.Render("←→ move · 1-5 jump · enter apply · esc cancel"), width)
139	149	}
140	150
	151	+ // effortAt is which level was clicked at column x. The nearest label wins
	152	+ // rather than only a hit on the word itself: the track between two labels
	153	+ // belongs to one of them, and a click on a slider that does nothing reads as
	154	+ // a broken slider.
	155	+ //
	156	+ // It goes through effortSlots, the same function the view lays the labels out
	157	+ // with, so the level a click picks is the one under the pointer whatever the
	158	+ // width does to the spacing.
	159	+ func effortAt(x, width int) (int, bool) {
	160	+ width = maxInt(1, width)
	161	+ starts := effortSlots(width - 1)
	162	+ if starts == nil {
	163	+ return 0, false
	164	+ }
	165	+ best, bestDist := 0, -1
	166	+ for i, level := range llm.EffortLevels {
	167	+ // The labels are drawn one column in, after the leading margin.
	168	+ centre := starts[i] + 1 + lipgloss.Width(level)/2
	169	+ if d := absInt(x - centre); bestDist < 0 \|\| d < bestDist {
	170	+ best, bestDist = i, d
	171	+ }
	172	+ }
	173	+ return best, true
	174	+ }
	175	+
	176	+ func absInt(n int) int {
	177	+ if n < 0 {
	178	+ return -n
	179	+ }
	180	+ return n
	181	+ }
	182	+
141	183	// effortSlots is the column each label starts at, spread evenly across width.
142	184	// It returns nil when the labels cannot be laid out with room to breathe,
143	185	// which is the caller's cue to render something simpler.

+98−35internal/tui/model.goView File

@@ -145,6 +145,21 @@ type model struct {
145	145	// say so while the agent unwinds.
146	146	interrupting bool
147	147
	148	+ // The mouse. mouseOn is whether the harness is asking the terminal for
	149	+ // mouse reporting at all: it costs the terminal's own text selection, so
	150	+ // /mouse gives it back. sel is the selection that replaces it, copied is
	151	+ // what the chrome says about the last copy, and the three click fields
	152	+ // are what turns a run of presses on one cell into a word or a line.
	153	+ mouseOn bool
	154	+ sel selection
	155	+ copied string
	156	+ clicks int
	157	+ clickAt cell
	158	+ clickTime time.Time
	159	+ // copyFn is how text leaves the harness. It is a field so a test can
	160	+ // watch what was copied without a clipboard, or a terminal, being there.
	161	+ copyFn func(string) error
	162	+
148	163	// wiz is the setup wizard. While it is non-nil it owns the screen and
149	164	// every key, and this model does nothing but hold its place.
150	165	wiz *wizard
@@ -198,12 +213,14 @@ func newModel(ctx context.Context, opts Options) *model {
198	213	sp.Style = styCoral
199	214
200	215	m := &model{
201		- opts: opts,
202		- bridge: &bridge{},
203		- input: ta,
204		- spin: sp,
205		- tr: newTranscript(80),
206		- parent: ctx,
	216	+ opts: opts,
	217	+ bridge: &bridge{},
	218	+ input: ta,
	219	+ spin: sp,
	220	+ tr: newTranscript(80),
	221	+ parent: ctx,
	222	+ mouseOn: true,
	223	+ copyFn: copyToClipboard,
207	224	}
208	225	m.tr.setVerbose(opts.Verbose)
209	226	m.tr.addRaw(splash(opts, 80))
@@ -219,7 +236,10 @@ func newModel(ctx context.Context, opts Options) *model {
219	236	// Run starts the program and blocks until the user exits.
220	237	func Run(ctx context.Context, opts Options) error {
221	238	m := newModel(ctx, opts)
222		- p := tea.NewProgram(m, tea.WithAltScreen(), tea.WithContext(ctx))
	239	+ // Cell motion rather than all motion: the drag is what has to be
	240	+ // followed, and reporting every pixel of idle movement would put a
	241	+ // message on the wire for a hand resting on the desk.
	242	+ p := tea.NewProgram(m, tea.WithAltScreen(), tea.WithMouseCellMotion(), tea.WithContext(ctx))
223	243
224	244	// The bridge can only learn the program after it exists; the agent does
225	245	// not touch it until the first turn starts, which is after Run.
@@ -250,6 +270,9 @@ func (m *model) Init() tea.Cmd {
250	270	// state untouched underneath: nothing about a running turn is disturbed,
251	271	// which is why /setup is safe to answer at any time the agent is idle.
252	272	func (m *model) openWizard() tea.Cmd {
	273	+ // The wizard takes the screen, and may come back with a different
	274	+ // palette; nothing selected underneath it survives that.
	275	+ m.clearSelection()
253	276	m.wiz = newWizard(m.opts.Client, m.opts.Config)
254	277	cmds := []tea.Cmd{m.wiz.Init()}
255	278	if m.ready {
@@ -353,6 +376,12 @@ func (m *model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
353	376	case tea.KeyMsg:
354	377	return m.onKey(msg)
355	378
	379	+ case tea.MouseMsg:
	380	+ return m.onMouse(msg)
	381	+
	382	+ case copiedMsg:
	383	+ return m, m.finishCopy(msg)
	384	+
356	385	case modelsMsg:
357	386	return m, m.onModels(msg)
358	387
@@ -412,6 +441,9 @@ func (m *model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
412	441	}
413	442
414	443	func (m *model) resize(w, h int) tea.Cmd {
	444	+ // Every line is about to be laid out again, so the line numbers a
	445	+ // selection is made of stop pointing at the text they were taken from.
	446	+ m.clearSelection()
415	447	m.width, m.height = w, h
416	448	m.tr.setWidth(w)
417	449	m.input.SetWidth(m.innerWidth())
@@ -518,6 +550,7 @@ func (m *model) onKey(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
518	550	return m, tea.Quit
519	551
520	552	case "esc":
	553	+ m.clearSelection()
521	554	if m.phase == phaseRunning {
522	555	return m, m.interrupt()
523	556	}
@@ -531,6 +564,9 @@ func (m *model) onKey(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
531	564	return m, tea.Quit
532	565
533	566	case "ctrl+r":
	567	+ // Collapsing or expanding tool output lays every line out again, so
	568	+ // the selection is about text that has moved.
	569	+ m.clearSelection()
534	570	m.tr.setVerbose(!m.tr.verbose)
535	571	state := "collapsed"
536	572	if m.tr.verbose {
@@ -568,6 +604,11 @@ func (m *model) onKey(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
568	604	return m.submit(line)
569	605	}
570	606
	607	+ // Typing moves on from whatever was selected, the way clicking elsewhere
	608	+ // does. Scrolling does not: reading further up the transcript with the
	609	+ // keys is no reason to lose what is marked.
	610	+ m.clearSelection()
	611	+
571	612	var cmd tea.Cmd
572	613	m.input, cmd = m.input.Update(msg)
573	614	m.growInput()
@@ -631,9 +672,13 @@ func (m *model) submit(line string) (tea.Model, tea.Cmd) {
631	672	return m, m.setEffort(strings.TrimSpace(strings.TrimPrefix(line, "/effort")))
632	673
633	674	case line == "/clear":
	675	+ m.clearSelection()
634	676	m.tr.clear()
635	677	return m, m.sync()
636	678
	679	+ case line == "/mouse":
	680	+ return m, m.toggleMouse()
	681	+
637	682	case line == "/allowed":
638	683	allowed := m.opts.Policy.Remembered()
639	684	if len(allowed) == 0 {
@@ -779,19 +824,29 @@ func (m *model) onApprovalKey(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
779	824	if !matches(c.keys, key) && key != fmt.Sprint(i+1) {
780	825	continue
781	826	}
782		- req.reply <- c.dec
783		- m.pending = m.pending[1:]
784		- if len(m.pending) == 0 {
785		- m.phase = phaseRunning
786		- }
787		- // The decision belongs to the call it gated, not to whatever the
788		- // transcript happens to end with once the result lands.
789		- m.tr.annotateTool(req.req.Tool, c.note)
790		- return m, tea.Batch(m.sync(), m.spin.Tick)
	827	+ return m, m.answerApproval(c)
791	828	}
792	829	return m, nil
793	830	}
794	831
	832	+ // answerApproval sends a decision and moves on. It is shared by the keys and
	833	+ // by a click on the choice, which must not be able to decide differently.
	834	+ func (m *model) answerApproval(c choice) tea.Cmd {
	835	+ if len(m.pending) == 0 {
	836	+ return nil
	837	+ }
	838	+ req := m.pending[0]
	839	+ req.reply <- c.dec
	840	+ m.pending = m.pending[1:]
	841	+ if len(m.pending) == 0 {
	842	+ m.phase = phaseRunning
	843	+ }
	844	+ // The decision belongs to the call it gated, not to whatever the
	845	+ // transcript happens to end with once the result lands.
	846	+ m.tr.annotateTool(req.req.Tool, c.note)
	847	+ return tea.Batch(m.sync(), m.spin.Tick)
	848	+ }
	849	+
795	850	func matches(keys []string, key string) bool {
796	851	for _, k := range keys {
797	852	if k == key {
@@ -825,28 +880,27 @@ func (m *model) View() string {
825	880	m.vp.GotoBottom()
826	881	}
827	882	}
828		- return m.vp.View() + "\n" + bottom
	883	+ // The guard is not only tidiness: asking the transcript for its lines
	884	+ // splits the whole scrollback, and a streaming turn redraws every frame.
	885	+ // Nothing pays for that until there is a selection to paint.
	886	+ view := m.vp.View()
	887	+ if m.sel.on {
	888	+ if from, to, ok := m.sel.span(m.tr.lines()); ok {
	889	+ view = paintSelection(view, m.vp.YOffset, from, to)
	890	+ }
	891	+ }
	892	+ return view + "\n" + bottom
829	893	}
830	894
	895	+ // bottom is the chrome under the transcript. It is assembled from layout()
	896	+ // rather than written out here, because a mouse click is resolved against
	897	+ // that same list and the two must be the same screen.
831	898	func (m *model) bottom() string {
832		- var b strings.Builder
833		- b.WriteString(m.activity() + "\n")
834		- switch {
835		- case m.phase == phaseApproving && len(m.pending) > 0:
836		- b.WriteString(m.approvalView() + "\n")
837		- case m.phase == phaseEffort:
838		- b.WriteString(m.effortView() + "\n")
839		- case m.phase == phaseModel:
840		- b.WriteString(m.modelView() + "\n")
841		- default:
842		- b.WriteString(m.inputBox() + "\n")
843		- if v := m.menuView(); v != "" {
844		- b.WriteString(v + "\n")
845		- }
	899	+ parts := make([]string, 0, 5)
	900	+ for _, s := range m.layout() {
	901	+ parts = append(parts, s.text)
846	902	}
847		- b.WriteString(m.status() + "\n")
848		- b.WriteString(m.modeLine())
849		- return b.String()
	903	+ return strings.Join(parts, "\n")
850	904	}
851	905
852	906	// activity is the line above the prompt: what the agent is doing on the left,
@@ -877,9 +931,18 @@ func (m *model) activity() string {
877	931	left = styWarn.Render("● waiting for you")
878	932	}
879	933
	934	+ // What was copied is reported here rather than in the transcript: five
	935	+ // copies should not cost five lines of scrollback, and this line is on
	936	+ // screen in every phase.
880	937	right := ""
	938	+ if m.copied != "" {
	939	+ right = styDim.Render(m.copied)
	940	+ }
881	941	if m.opts.Effort != "" {
882		- right = styDim.Render("● "+m.opts.Effort) + styFaint.Render(" · /effort")
	942	+ if right != "" {
	943	+ right += styFaint.Render(" · ")
	944	+ }
	945	+ right += styDim.Render("● "+m.opts.Effort) + styFaint.Render(" · /effort")
883	946	}
884	947	return spread(left, right, m.width)
885	948	}

+19−10internal/tui/model_picker.goView File

@@ -149,16 +149,7 @@ func (m *model) modelView() string {
149	149	return head + "\n" + truncateStyled(" "+m.spin.View()+" "+from+styFaint.Render(" · esc to cancel"), width)
150	150	}
151	151
152		- rows := m.modelRows()
153		- shown := rows
154		- if len(m.models) > rows {
155		- shown = maxInt(1, rows-1)
156		- }
157		- start := 0
158		- if m.modelIdx >= shown {
159		- start = m.modelIdx - shown + 1
160		- }
161		- end := minInt(len(m.models), start+shown)
	152	+ start, end := m.modelWindow()
162	153
163	154	// One column for the names, so the ids line up under each other.
164	155	names := make([]string, len(m.models))
@@ -213,6 +204,24 @@ func (m *model) modelView() string {
213	204	return strings.TrimRight(b.String(), "\n")
214	205	}
215	206
	207	+ // modelHeadRows is how many rows come before the list: the heading, and the
	208	+ // line saying where the models came from.
	209	+ const modelHeadRows = 2
	210	+
	211	+ // modelWindow is the slice of the list that is on screen, shared by the view
	212	+ // and by the hit test, so a click lands on the model it looks like it is on.
	213	+ func (m *model) modelWindow() (start, end int) {
	214	+ rows := m.modelRows()
	215	+ shown := rows
	216	+ if len(m.models) > rows {
	217	+ shown = maxInt(1, rows-1)
	218	+ }
	219	+ if m.modelIdx >= shown {
	220	+ start = m.modelIdx - shown + 1
	221	+ }
	222	+ return start, minInt(len(m.models), start+shown)
	223	+ }
	224	+
216	225	// modelRows is how many model rows fit: the same arithmetic the completion
217	226	// menu does, minus the heading and the line saying where the list came from.
218	227	func (m *model) modelRows() int {

+355−0internal/tui/mouse.goaddedView File

++ package tui
++ import (
++ 	"time"
++ 	"github.com/charmbracelet/bubbles/textarea"
++ 	tea "github.com/charmbracelet/bubbletea"
++ 	"github.com/charmbracelet/lipgloss"
++ 	"harness/internal/llm"
++ )
++ // The mouse is handled here the way keys are handled in onKey: one entry
++ // point, the piece of the screen under the pointer decides who answers.
++ //
++ // Everything a terminal would normally do with a drag it stops doing the
++ // moment mouse reporting is asked for, so what this file adds is not only new
++ // behaviour — the wheel, clickable chrome — but also the replacement for what
++ // enabling the mouse takes away. /mouse gives it all back.
++ // doubleClick is how close two presses on the same cell have to be to count
++ // as a double-click. 400ms is the middle of what desktops use.
++ const doubleClick = 400 * time.Millisecond
++ // sectionKind names a piece of the screen. The transcript is one of them so
++ // that a hit test always has an answer.
++ type sectionKind int
++ const (
++ 	secTranscript sectionKind = iota
++ 	secActivity
++ 	secInput
++ 	secMenu
++ 	secStatus
++ 	secMode
++ 	secApproval
++ 	secEffort
++ 	secModel
++ )
++ // section is one piece of the bottom chrome and what it rendered to. The
++ // layout is built from these rather than from a tally of heights kept
++ // somewhere else, so where a click lands and what was drawn cannot disagree.
++ type section struct {
++ 	kind sectionKind
++ 	text string
++ }
++ // layout is the bottom chrome, in order. It is what bottom() joins together
++ // and what a mouse event is resolved against, which is the point: a click
++ // finds the same rows the frame drew.
++ func (m *model) layout() []section {
++ 	secs := []section{{secActivity, m.activity()}}
++ 	switch {
++ 	case m.phase == phaseApproving && len(m.pending) > 0:
++ 		secs = append(secs, section{secApproval, m.approvalView()})
++ 	case m.phase == phaseEffort:
++ 		secs = append(secs, section{secEffort, m.effortView()})
++ 	case m.phase == phaseModel:
++ 		secs = append(secs, section{secModel, m.modelView()})
++ 	default:
++ 		secs = append(secs, section{secInput, m.inputBox()})
++ 		if v := m.menuView(); v != "" {
++ 			secs = append(secs, section{secMenu, v})
++ 		}
++ 	}
++ 	return append(secs, section{secStatus, m.status()}, section{secMode, m.modeLine()})
++ }
++ // chromeRows is how many rows the bottom chrome takes, and so where the
++ // transcript ends.
++ func (m *model) chromeRows() int { return rowsOf(m.layout()) }
++ func rowsOf(secs []section) int {
++ 	n := 0
++ 	for _, s := range secs {
++ 		n += lipgloss.Height(s.text)
++ 	}
++ 	return n
++ }
++ // hitIn says what is at screen row y: which piece of the screen, and which of
++ // that piece's own rows. top is the first row the chrome occupies, which is
++ // also how many rows the transcript has.
++ func hitIn(secs []section, top, y int) (sectionKind, int) {
++ 	if y < top {
++ 		return secTranscript, y
++ 	}
++ 	for _, s := range secs {
++ 		n := lipgloss.Height(s.text)
++ 		if y < top+n {
++ 			return s.kind, y - top
++ 		}
++ 		top += n
++ 	}
++ 	return secTranscript, y
++ }
++ func (m *model) onMouse(msg tea.MouseMsg) (tea.Model, tea.Cmd) {
++ 	// The wizard owns the whole screen, and it is keyboard-driven; the chrome
++ 	// underneath it is not on screen to be clicked.
++ 	if !m.mouseOn || m.wiz != nil {
++ 		return m, nil
++ 	}
++ 	// The screen is measured once per event rather than once per question
++ 	// asked about it: laying the chrome out is cheap, but a drag asks several
++ 	// times a frame.
++ 	secs := m.layout()
++ 	rows := maxInt(1, m.height-rowsOf(secs))
++ 	kind, row := hitIn(secs, rows, msg.Y)
++ 	// A drag that has wandered into the chrome is still that drag. Following
++ 	// it past the edge of the transcript is what lets a selection run further
++ 	// than one screenful.
++ 	if m.sel.drag && msg.Action != tea.MouseActionPress {
++ 		kind, row = secTranscript, minInt(row, rows-1)
++ 	}
++ 	if kind == secTranscript {
++ 		return m, m.onTranscriptMouse(msg, row, rows)
++ 	}
++ 	if isWheel(msg) {
++ 		return m, m.onChromeWheel(kind, msg)
++ 	}
++ 	if msg.Action != tea.MouseActionPress || msg.Button != tea.MouseButtonLeft {
++ 		return m, nil
++ 	}
++ 	return m.onChromeClick(kind, row, msg.X)
++ }
++ // onTranscriptMouse is the scrollback: the wheel rolls it, a drag marks text
++ // on it.
++ func (m *model) onTranscriptMouse(msg tea.MouseMsg, row, rows int) tea.Cmd {
++ 	if isWheel(msg) {
++ 		var cmd tea.Cmd
++ 		m.vp, cmd = m.vp.Update(msg)
++ 		return cmd
++ 	}
++ 	switch {
++ 	case msg.Action == tea.MouseActionPress && msg.Button == tea.MouseButtonLeft:
++ 		return m.pressTranscript(row, msg.X, msg.Shift)
++ 	case msg.Action == tea.MouseActionMotion && m.sel.drag:
++ 		// Dragging against either edge scrolls, so a selection can be longer
++ 		// than the screen. Movement is what keeps it going: with button-event
++ 		// reporting a hand held still at the edge sends nothing at all.
++ 		switch {
++ 		case row <= 0:
++ 			m.vp.ScrollUp(1)
++ 		case row >= rows-1:
++ 			m.vp.ScrollDown(1)
++ 		}
++ 		m.sel.to(m.cellAt(row, msg.X))
++ 		return nil
++ 	case msg.Action == tea.MouseActionRelease:
++ 		if !m.sel.drag {
++ 			return nil
++ 		}
++ 		m.sel.release()
++ 		if !m.sel.on {
++ 			// A press and a release with nothing in between is a click, which
++ 			// is how a selection is dismissed.
++ 			m.clearSelection()
++ 			return nil
++ 		}
++ 		return m.copySelection()
++ 	}
++ 	return nil
++ }
++ // pressTranscript starts a selection, or widens the one a second and third
++ // click on the same cell are asking for.
++ func (m *model) pressTranscript(row, x int, shift bool) tea.Cmd {
++ 	c := m.cellAt(row, x)
++ 	now := time.Now()
++ 	if c == m.clickAt && now.Sub(m.clickTime) < doubleClick {
++ 		m.clicks++
++ 	} else {
++ 		m.clicks = 1
++ 	}
++ 	m.clickAt, m.clickTime = c, now
++ 	m.copied = ""
++ 	m.sel.press(c, shift)
++ 	switch m.clicks {
++ 	case 2:
++ 		m.sel.widen(selWord)
++ 	case 3:
++ 		m.sel.widen(selLine)
++ 	default:
++ 		return nil
++ 	}
++ 	// A double-click is a whole gesture on its own: there is no release to
++ 	// wait for before the word is there to be taken.
++ 	return m.copySelection()
++ }
++ // cellAt is which piece of the transcript is under the pointer. A column past
++ // the end of a line clamps to it, so dragging through the empty right-hand
++ // side of the screen selects to the end of the text rather than to nothing.
++ func (m *model) cellAt(row, x int) cell {
++ 	lines := m.tr.lines()
++ 	if len(lines) == 0 {
++ 		return cell{}
++ 	}
++ 	line := clampLine(m.vp.YOffset+row, lines)
++ 	return cell{line: line, col: maxInt(0, minInt(x, lineWidth(lines, line)))}
++ }
++ // copySelection puts the marked text on the clipboard. The write happens off
++ // the update loop because one of the two ways it is done shells out to the
++ // desktop's clipboard helper, and that can be slow or hang.
++ func (m *model) copySelection() tea.Cmd {
++ 	lines := m.tr.lines()
++ 	from, to, ok := m.sel.span(lines)
++ 	if !ok {
++ 		return nil
++ 	}
++ 	text := selectedText(lines, from, to)
++ 	if text == "" {
++ 		return nil
++ 	}
++ 	copyFn := m.copyFn
++ 	return func() tea.Msg {
++ 		return copiedMsg{text: text, err: copyFn(text)}
++ 	}
++ }
++ func (m *model) clearSelection() {
++ 	m.sel.clear()
++ 	m.copied = ""
++ 	m.clicks = 0
++ }
++ // onChromeWheel rolls whatever is under the pointer. Over a list that is the
++ // list — the wheel does what ↑↓ do — and over anything else it is still the
++ // transcript, because a wheel that does nothing feels broken.
++ func (m *model) onChromeWheel(kind sectionKind, msg tea.MouseMsg) tea.Cmd {
++ 	up := msg.Button == tea.MouseButtonWheelUp
++ 	switch kind {
++ 	case secMenu:
++ 		if n := len(m.menu.items); n > 0 {
++ 			m.menu.idx = (m.menu.idx + n + step(up)) % n
++ 		}
++ 		return nil
++ 	case secModel:
++ 		if len(m.models) > 0 {
++ 			m.modelIdx = clampIdx(m.modelIdx+step(up), len(m.models))
++ 		}
++ 		return nil
++ 	case secEffort:
++ 		m.effortIdx = clampIdx(m.effortIdx+step(up), len(llm.EffortLevels))
++ 		return nil
++ 	}
++ 	var cmd tea.Cmd
++ 	m.vp, cmd = m.vp.Update(msg)
++ 	return cmd
++ }
++ // onChromeClick answers a click on the furniture. A click is a choice: it
++ // does what pressing enter on that row would do, rather than only moving a
++ // highlight there and waiting to be told again.
++ func (m *model) onChromeClick(kind sectionKind, row, x int) (tea.Model, tea.Cmd) {
++ 	switch kind {
++ 	case secMenu:
++ 		start, end := m.menuWindow()
++ 		if i := start + row; i < end {
++ 			m.menu.idx = i
++ 			m.acceptCompletion()
++ 		}
++ 		return m, nil
++ 	case secModel:
++ 		if m.modelsLoading {
++ 			return m, nil
++ 		}
++ 		// The heading and the line saying where the list came from sit above
++ 		// the rows.
++ 		start, end := m.modelWindow()
++ 		if i := start + row - modelHeadRows; row >= modelHeadRows && i < end {
++ 			m.modelIdx = i
++ 			id := m.models[i].ID
++ 			m.phase, m.models = phaseIdle, nil
++ 			m.applyModel(id)
++ 			return m, tea.Batch(m.sync(), textarea.Blink)
++ 		}
++ 		return m, nil
++ 	case secEffort:
++ 		if row != effortTrackRow && row != effortLabelRow {
++ 			return m, nil
++ 		}
++ 		if i, ok := effortAt(x, m.width); ok {
++ 			m.effortIdx = i
++ 			m.phase = phaseIdle
++ 			m.applyEffort(llm.EffortLevels[i])
++ 			return m, tea.Batch(m.sync(), textarea.Blink)
++ 		}
++ 		return m, nil
++ 	case secApproval:
++ 		if len(m.pending) == 0 {
++ 			return m, nil
++ 		}
++ 		opts := m.choices(m.pending[0].req)
++ 		if i := row - approvalChoiceRow(m.approvalView(), len(opts)); i >= 0 && i < len(opts) {
++ 			return m, m.answerApproval(opts[i])
++ 		}
++ 		return m, nil
++ 	case secMode:
++ 		return m, m.cycleMode()
++ 	}
++ 	return m, nil
++ }
++ // toggleMouse hands the mouse to the terminal or takes it back. With
++ // reporting on, the terminal stops sending drags to its own selection and
++ // sends them here instead — which is the whole feature, and also the cost of
++ // it, because the terminal's selection is what works when the harness's own
++ // is not what you want.
++ func (m *model) toggleMouse() tea.Cmd {
++ 	m.mouseOn = !m.mouseOn
++ 	m.clearSelection()
++ 	if m.mouseOn {
++ 		m.tr.addNotice("mouse on — drag to select, double-click a word, triple-click a line, wheel scrolls")
++ 		return tea.Batch(m.sync(), tea.EnableMouseCellMotion)
++ 	}
++ 	m.tr.addNotice("mouse off — your terminal's own selection and copy are back. /mouse to take it again")
++ 	return tea.Batch(m.sync(), tea.DisableMouse)
++ }
++ // approvalChoiceRow is the row the first choice sits on inside the approval
++ // box. The choices are the last thing in the box, so counting back from its
++ // bottom border cannot drift from however the detail above them was laid out.
++ func approvalChoiceRow(view string, choices int) int {
++ 	return maxInt(0, lipgloss.Height(view)-1-choices)
++ }
++ // isWheel reports a wheel event. MouseMsg is its own type over MouseEvent, so
++ // the event's own test is not promoted onto it.
++ func isWheel(msg tea.MouseMsg) bool { return tea.MouseEvent(msg).IsWheel() }
++ func step(up bool) int {
++ 	if up {
++ 		return -1
++ 	}
++ 	return 1
++ }
++ func clampIdx(i, n int) int { return maxInt(0, minInt(i, n-1)) }

+561−0internal/tui/mouse_test.goaddedView File

++ package tui
++ import (
++ 	"bytes"
++ 	"context"
++ 	"errors"
++ 	"io"
++ 	"strings"
++ 	"sync"
++ 	"testing"
++ 	"time"
++ 	tea "github.com/charmbracelet/bubbletea"
++ 	"github.com/charmbracelet/lipgloss"
++ 	"github.com/muesli/termenv"
++ 	"harness/internal/approval"
++ 	"harness/internal/llm"
++ )
++ func press(x, y int) tea.MouseMsg {
++ 	return tea.MouseMsg{X: x, Y: y, Action: tea.MouseActionPress, Button: tea.MouseButtonLeft}
++ }
++ func motion(x, y int) tea.MouseMsg {
++ 	return tea.MouseMsg{X: x, Y: y, Action: tea.MouseActionMotion, Button: tea.MouseButtonLeft}
++ }
++ func release(x, y int) tea.MouseMsg {
++ 	return tea.MouseMsg{X: x, Y: y, Action: tea.MouseActionRelease}
++ }
++ func wheel(x, y int, up bool) tea.MouseMsg {
++ 	button := tea.MouseButtonWheelDown
++ 	if up {
++ 		button = tea.MouseButtonWheelUp
++ 	}
++ 	return tea.MouseMsg{X: x, Y: y, Action: tea.MouseActionPress, Button: button}
++ }
++ // mouseModel is a model whose transcript is known text rather than the
++ // welcome block, with the clipboard captured instead of written.
++ func mouseModel(t *testing.T, lines ...string) (*model, *string) {
++ 	t.Helper()
++ 	m := newTestModel(t)
++ 	m.tr.clear()
++ 	for _, line := range lines {
++ 		m.tr.addRaw(line)
++ 	}
++ 	m.sync()
++ 	var clipboard string
++ 	m.copyFn = func(s string) error {
++ 		clipboard = s
++ 		return nil
++ 	}
++ 	return m, &clipboard
++ }
++ // rowOf is the inverse of the hit test: which screen row a given row of a
++ // given piece of the chrome is drawn on. Tests click what they can see, and
++ // this is how they find it.
++ func (m *model) rowOf(kind sectionKind, row int) (int, bool) {
++ 	top := m.height - m.chromeRows()
++ 	for _, s := range m.layout() {
++ 		n := lipgloss.Height(s.text)
++ 		if s.kind == kind {
++ 			if row >= n {
++ 				return 0, false
++ 			}
++ 			return top + row, true
++ 		}
++ 		top += n
++ 	}
++ 	return 0, false
++ }
++ // The wheel is the whole reason mouse reporting is on: in the alternate
++ // screen the terminal has no scrollback of its own to roll.
++ func TestTheWheelScrollsTheTranscript(t *testing.T) {
++ 	m := newTestModel(t)
++ 	for i := 0; i < 200; i++ {
++ 		m.tr.addNotice("line")
++ 	}
++ 	m.sync()
++ 	m.View()
++ 	bottom := m.vp.YOffset
++ 	if bottom == 0 {
++ 		t.Fatal("a 200-entry transcript did not scroll the viewport at all")
++ 	}
++ 	m.Update(wheel(10, 1, true))
++ 	if m.vp.YOffset != bottom-3 {
++ 		t.Errorf("wheel up moved %d lines, want 3", bottom-m.vp.YOffset)
++ 	}
++ 	m.Update(wheel(10, 1, false))
++ 	if m.vp.YOffset != bottom {
++ 		t.Errorf("wheel down did not come back to where it started: %d, want %d", m.vp.YOffset, bottom)
++ 	}
++ }
++ func TestDraggingOverTheTranscriptCopiesWhatWasMarked(t *testing.T) {
++ 	m, clipboard := mouseModel(t, "the quick brown fox", "jumps over the lazy dog")
++ 	m.Update(press(4, 0))
++ 	m.Update(motion(8, 0))
++ 	_, cmd := m.Update(release(8, 0))
++ 	drain(t, m, cmd)
++ 	if *clipboard != "quick" {
++ 		t.Errorf("clipboard holds %q, want %q", *clipboard, "quick")
++ 	}
++ 	if !m.sel.on {
++ 		t.Error("the selection vanished when the button came up")
++ 	}
++ }
++ func TestDraggingAcrossLinesCopiesBothOfThem(t *testing.T) {
++ 	m, clipboard := mouseModel(t, "the quick brown fox", "jumps over the lazy dog")
++ 	m.Update(press(16, 0))
++ 	m.Update(motion(4, 1))
++ 	_, cmd := m.Update(release(4, 1))
++ 	drain(t, m, cmd)
++ 	if want := "fox\njumps"; *clipboard != want {
++ 		t.Errorf("clipboard holds %q, want %q", *clipboard, want)
++ 	}
++ }
++ // A click is how a selection is dismissed, so it must not put a stray
++ // character on the clipboard on the way.
++ func TestAClickClearsTheSelectionAndCopiesNothing(t *testing.T) {
++ 	m, clipboard := mouseModel(t, "the quick brown fox")
++ 	m.Update(press(4, 0))
++ 	m.Update(motion(8, 0))
++ 	m.Update(release(8, 0))
++ 	*clipboard = ""
++ 	m.Update(press(2, 0))
++ 	_, cmd := m.Update(release(2, 0))
++ 	drain(t, m, cmd)
++ 	if m.sel.on {
++ 		t.Error("a click left a selection behind")
++ 	}
++ 	if *clipboard != "" {
++ 		t.Errorf("a click copied %q", *clipboard)
++ 	}
++ }
++ func TestDoubleClickTakesAWordAndTripleClickTheLine(t *testing.T) {
++ 	m, clipboard := mouseModel(t, "edited internal/tui/model.go:222 for you")
++ 	m.Update(press(12, 0))
++ 	_, cmd := m.Update(press(12, 0))
++ 	drain(t, m, cmd)
++ 	if want := "internal/tui/model.go:222"; *clipboard != want {
++ 		t.Errorf("double-click copied %q, want %q", *clipboard, want)
++ 	}
++ 	_, cmd = m.Update(press(12, 0))
++ 	drain(t, m, cmd)
++ 	if want := "edited internal/tui/model.go:222 for you"; *clipboard != want {
++ 		t.Errorf("triple-click copied %q, want %q", *clipboard, want)
++ 	}
++ }
++ // Dragging off the top edge is how you select more than one screenful, so it
++ // has to scroll rather than stop at the first row.
++ func TestDraggingPastTheTopScrollsTheTranscript(t *testing.T) {
++ 	m := newTestModel(t)
++ 	for i := 0; i < 200; i++ {
++ 		m.tr.addNotice("line")
++ 	}
++ 	m.sync()
++ 	m.View()
++ 	before := m.vp.YOffset
++ 	m.Update(press(4, 3))
++ 	m.Update(motion(4, 0))
++ 	m.Update(motion(3, 0))
++ 	if m.vp.YOffset >= before {
++ 		t.Errorf("dragging to the top row did not scroll up: offset %d, was %d", m.vp.YOffset, before)
++ 	}
++ }
++ // What was copied is reported where the agent's own status goes, not in the
++ // transcript: copying five things should not leave five lines of scrollback.
++ func TestCopyingSaysSoWithoutWritingToTheTranscript(t *testing.T) {
++ 	m, _ := mouseModel(t, "the quick brown fox", "jumps over the lazy dog")
++ 	entries := len(m.tr.entries)
++ 	m.Update(press(0, 0))
++ 	m.Update(motion(4, 1))
++ 	_, cmd := m.Update(release(4, 1))
++ 	drain(t, m, cmd)
++ 	if !strings.Contains(m.activity(), "copied 2 lines") {
++ 		t.Errorf("the activity line does not report the copy: %q", m.activity())
++ 	}
++ 	if len(m.tr.entries) != entries {
++ 		t.Errorf("copying added %d transcript entries", len(m.tr.entries)-entries)
++ 	}
++ }
++ // The lines a selection names belong to a layout. Anything that lays the
++ // transcript out again — a resize, or opening up tool output — leaves those
++ // line numbers pointing at different text, so the selection goes.
++ func TestRelayingOutTheTranscriptDropsTheSelection(t *testing.T) {
++ 	for _, tc := range []struct {
++ 		name string
++ 		do   func(m *model)
++ 	}{
++ 		{"a resize", func(m *model) { m.Update(tea.WindowSizeMsg{Width: 100, Height: 30}) }},
++ 		{"expanding tool output", func(m *model) { m.Update(key("ctrl+r")) }},
++ 		{"typing", func(m *model) { m.Update(key("a")) }},
++ 	} {
++ 		m, _ := mouseModel(t, "the quick brown fox")
++ 		m.Update(press(4, 0))
++ 		m.Update(motion(8, 0))
++ 		m.Update(release(8, 0))
++ 		if !m.sel.on {
++ 			t.Fatalf("%s: no selection to begin with", tc.name)
++ 		}
++ 		tc.do(m)
++ 		if m.sel.on {
++ 			t.Errorf("%s left a selection pointing at the old layout", tc.name)
++ 		}
++ 	}
++ }
++ func TestClickingACompletionRowAcceptsIt(t *testing.T) {
++ 	m := newTestModel(t)
++ 	m.input.SetValue("/")
++ 	m.refreshMenu()
++ 	if !m.menuOpen() {
++ 		t.Fatal("the completion menu did not open")
++ 	}
++ 	want := "/" + m.menu.items[2].name
++ 	m.View()
++ 	row, ok := m.rowOf(secMenu, 2)
++ 	if !ok {
++ 		t.Fatal("the completion menu is not on screen anywhere")
++ 	}
++ 	m.Update(press(4, row))
++ 	if got := strings.TrimSpace(m.input.Value()); got != want {
++ 		t.Errorf("clicking the third row put %q in the prompt, want %q", got, want)
++ 	}
++ }
++ func TestClickingAModelRowPicksThatModel(t *testing.T) {
++ 	m := newTestModel(t)
++ 	m.openModelPicker()
++ 	m.Update(modelsMsg{models: someModels()})
++ 	if m.phase != phaseModel {
++ 		t.Fatal("the picker is not open")
++ 	}
++ 	m.View()
++ 	// Two rows of heading come before the list.
++ 	row, ok := m.rowOf(secModel, 3)
++ 	if !ok {
++ 		t.Fatal("the model picker is not on screen anywhere")
++ 	}
++ 	m.Update(press(4, row))
++ 	if got := m.opts.Client.Model(); got != "claude-sonnet-5" {
++ 		t.Errorf("clicking the second model chose %q", got)
++ 	}
++ 	if m.phase != phaseIdle {
++ 		t.Error("the picker stayed open after a model was clicked")
++ 	}
++ }
++ // The wheel moves through a list the same way the arrow keys do: over an open
++ // picker it is not the transcript being rolled.
++ func TestTheWheelMovesThroughAnOpenPicker(t *testing.T) {
++ 	m := newTestModel(t)
++ 	m.openModelPicker()
++ 	m.Update(modelsMsg{models: someModels()})
++ 	m.View()
++ 	row, _ := m.rowOf(secModel, 2)
++ 	m.Update(wheel(4, row, false))
++ 	if m.modelIdx != 1 {
++ 		t.Errorf("wheel down over the picker moved to %d, want 1", m.modelIdx)
++ 	}
++ 	m.Update(wheel(4, row, true))
++ 	if m.modelIdx != 0 {
++ 		t.Errorf("wheel up over the picker moved to %d, want 0", m.modelIdx)
++ 	}
++ }
++ func TestClickingTheEffortSliderPicksThatLevel(t *testing.T) {
++ 	m := newTestModel(t)
++ 	m.Update(tea.WindowSizeMsg{Width: 120, Height: 30})
++ 	m.openEffort()
++ 	m.View()
++ 	// The labels row, under the level the last slot holds.
++ 	row, ok := m.rowOf(secEffort, 2)
++ 	if !ok {
++ 		t.Fatal("the slider is not on screen anywhere")
++ 	}
++ 	last := len(llm.EffortLevels) - 1
++ 	m.Update(press(effortSlots(119)[last], row))
++ 	if m.opts.Effort != llm.EffortLevels[last] {
++ 		t.Errorf("clicking the last label set effort to %q, want %q", m.opts.Effort, llm.EffortLevels[last])
++ 	}
++ }
++ // The slider is four rows, and two of them are words about it: the poles
++ // above the track and the keys below the labels. Only the track and the
++ // labels are the slider itself.
++ func TestClickingTheSliderChromeChangesNothing(t *testing.T) {
++ 	for _, row := range []int{0, 3} {
++ 		m := newTestModel(t)
++ 		m.Update(tea.WindowSizeMsg{Width: 120, Height: 30})
++ 		m.openEffort()
++ 		m.View()
++ 		y, ok := m.rowOf(secEffort, row)
++ 		if !ok {
++ 			t.Fatalf("row %d of the slider is not on screen", row)
++ 		}
++ 		m.Update(press(effortSlots(119)[len(llm.EffortLevels)-1], y))
++ 		if m.opts.Effort != "" {
++ 			t.Errorf("clicking row %d of the slider set effort to %q", row, m.opts.Effort)
++ 		}
++ 		if m.phase != phaseEffort {
++ 			t.Errorf("clicking row %d of the slider closed it", row)
++ 		}
++ 	}
++ }
++ func TestClickingAnApprovalChoiceAnswersIt(t *testing.T) {
++ 	m := newTestModel(t)
++ 	reply := pend(m, approval.Request{Tool: "bash", Summary: "run ls"})
++ 	m.View()
++ 	opts := m.choices(m.pending[0].req)
++ 	row, ok := m.rowOf(secApproval, approvalChoiceRow(m.approvalView(), len(opts))+len(opts)-1)
++ 	if !ok {
++ 		t.Fatal("the approval box is not on screen anywhere")
++ 	}
++ 	m.Update(press(4, row))
++ 	select {
++ 	case got := <-reply:
++ 		if got != approval.Deny {
++ 			t.Errorf("clicking the last choice decided %v, want deny", got)
++ 		}
++ 	default:
++ 		t.Fatal("clicking a choice decided nothing")
++ 	}
++ }
++ func TestClickingTheModeLineCyclesApprovals(t *testing.T) {
++ 	m := newTestModel(t)
++ 	m.View()
++ 	row, ok := m.rowOf(secMode, 0)
++ 	if !ok {
++ 		t.Fatal("the mode line is not on screen anywhere")
++ 	}
++ 	m.Update(press(2, row))
++ 	if !m.opts.Policy.YOLO {
++ 		t.Error("clicking the mode line did not cycle the approval mode")
++ 	}
++ }
++ // /mouse hands the mouse back to the terminal, which is the only way to get
++ // the terminal's own selection back for a copy the harness cannot do.
++ func TestMouseCanBeHandedBackToTheTerminal(t *testing.T) {
++ 	m, clipboard := mouseModel(t, "the quick brown fox")
++ 	m.submit("/mouse")
++ 	if m.mouseOn {
++ 		t.Fatal("/mouse left mouse reporting on")
++ 	}
++ 	m.Update(press(4, 0))
++ 	m.Update(motion(8, 0))
++ 	_, cmd := m.Update(release(8, 0))
++ 	drain(t, m, cmd)
++ 	if m.sel.on || *clipboard != "" {
++ 		t.Errorf("a drag was still handled with the mouse off: selection=%v clipboard=%q", m.sel.on, *clipboard)
++ 	}
++ 	m.submit("/mouse")
++ 	if !m.mouseOn {
++ 		t.Error("/mouse did not turn reporting back on")
++ 	}
++ }
++ // Shift and a click move the far end of what is already selected, which is
++ // how a selection is corrected without starting it again.
++ func TestShiftClickExtendsTheSelection(t *testing.T) {
++ 	m, clipboard := mouseModel(t, "the quick brown fox")
++ 	m.Update(press(4, 0))
++ 	m.Update(motion(8, 0))
++ 	m.Update(release(8, 0))
++ 	shift := press(14, 0)
++ 	shift.Shift = true
++ 	m.Update(shift)
++ 	_, cmd := m.Update(release(14, 0))
++ 	drain(t, m, cmd)
++ 	if want := "quick brown"; *clipboard != want {
++ 		t.Errorf("shift+click copied %q, want %q", *clipboard, want)
++ 	}
++ }
++ func TestDraggingPastTheBottomScrollsTheTranscript(t *testing.T) {
++ 	m := newTestModel(t)
++ 	for i := 0; i < 200; i++ {
++ 		m.tr.addNotice("line")
++ 	}
++ 	m.sync()
++ 	m.View()
++ 	m.vp.GotoTop()
++ 	before := m.vp.YOffset
++ 	rows := m.height - m.chromeRows()
++ 	m.Update(press(4, rows-4))
++ 	m.Update(motion(4, rows-1))
++ 	m.Update(motion(3, rows-1))
++ 	if m.vp.YOffset <= before {
++ 		t.Errorf("dragging to the bottom row did not scroll down: offset %d, was %d", m.vp.YOffset, before)
++ 	}
++ }
++ // A clipboard that would not take the text is worth interrupting the
++ // transcript for: the text is not where the person is about to paste from.
++ func TestAFailedCopySaysSoInTheTranscript(t *testing.T) {
++ 	m, _ := mouseModel(t, "the quick brown fox")
++ 	m.copyFn = func(string) error { return errors.New("no clipboard here") }
++ 	entries := len(m.tr.entries)
++ 	m.Update(press(4, 0))
++ 	m.Update(motion(8, 0))
++ 	_, cmd := m.Update(release(8, 0))
++ 	drain(t, m, cmd)
++ 	if len(m.tr.entries) != entries+1 {
++ 		t.Fatalf("a failed copy added %d entries, want 1", len(m.tr.entries)-entries)
++ 	}
++ 	if last := m.tr.entries[len(m.tr.entries)-1]; !strings.Contains(last.text, "no clipboard here") {
++ 		t.Errorf("the failure was not reported: %q", last.text)
++ 	}
++ }
++ // lockedBuffer is a writer the renderer's own goroutine and the test can both
++ // touch. Bubble Tea draws on a ticker, so frames are still landing while the
++ // test is reading what was drawn.
++ type lockedBuffer struct {
++ 	mu  sync.Mutex
++ 	buf bytes.Buffer
++ }
++ func (b *lockedBuffer) Write(p []byte) (int, error) {
++ 	b.mu.Lock()
++ 	defer b.mu.Unlock()
++ 	return b.buf.Write(p)
++ }
++ func (b *lockedBuffer) String() string {
++ 	b.mu.Lock()
++ 	defer b.mu.Unlock()
++ 	return b.buf.String()
++ }
++ // Everything above drives the model with messages the program would have
++ // made. This one starts the real program and feeds it the bytes a terminal
++ // actually sends — SGR press, motion, release — because the wire format is
++ // half of what "the mouse works" means, and nothing else here would catch it
++ // being asked for wrongly.
++ func TestARealDragPaintsAndCopies(t *testing.T) {
++ 	forceColour(t)
++ 	m := newModel(context.Background(), Options{
++ 		Client: llm.New(llm.WithAPIKey("x")),
++ 		Root:   "/tmp/repo",
++ 		Policy: approval.New(nil),
++ 	})
++ 	m.resize(80, 24)
++ 	m.tr.clear()
++ 	m.tr.addRaw("the quick brown fox")
++ 	m.sync()
++ 	copied := make(chan string, 1)
++ 	m.copyFn = func(s string) error {
++ 		select {
++ 		case copied <- s:
++ 		default:
++ 		}
++ 		return nil
++ 	}
++ 	// SGR mouse reports: button 0 pressed at (5,1), moved (32 is button 0
++ 	// held) to (9,1), released there. Columns and rows are 1-based on the
++ 	// wire. Then ctrl+c, which is what ends the program — after a pause, so
++ 	// that the drag gets a frame drawn for it before the screen goes away.
++ 	in, drag := io.Pipe()
++ 	go func() {
++ 		drag.Write([]byte("\x1b[<0;5;1M" + "\x1b[<32;9;1M" + "\x1b[<0;9;1m"))
++ 		time.Sleep(100 * time.Millisecond)
++ 		drag.Write([]byte("\x03"))
++ 		drag.Close()
++ 	}()
++ 	var out lockedBuffer
++ 	p := tea.NewProgram(m,
++ 		tea.WithInput(in),
++ 		tea.WithOutput(&out),
++ 		tea.WithAltScreen(),
++ 		tea.WithMouseCellMotion(),
++ 		tea.WithoutSignalHandler(),
++ 	)
++ 	if _, err := p.Run(); err != nil {
++ 		t.Fatalf("running the program: %v", err)
++ 	}
++ 	select {
++ 	case got := <-copied:
++ 		if got != "quick" {
++ 			t.Errorf("a real drag copied %q, want %q", got, "quick")
++ 		}
++ 	default:
++ 		t.Error("a real drag copied nothing")
++ 	}
++ 	// The frame the drag produced carries the selection behind the marked
++ 	// text, which is the other half of the wire: the bytes going back out.
++ 	if want := termenv.TrueColor.Color(colSelBg.Dark).Sequence(true); !strings.Contains(out.String(), want) {
++ 		t.Error("no frame painted the selection")
++ 	}
++ 	// The terminal is asked for button-event mouse reporting, and asked to
++ 	// stop on the way out.
++ 	if !strings.Contains(out.String(), "\x1b[?1002h") {
++ 		t.Error("the program never turned mouse reporting on")
++ 	}
++ 	if !strings.Contains(out.String(), "\x1b[?1002l") {
++ 		t.Error("the program left mouse reporting on after it exited")
++ 	}
++ }

+272−0internal/tui/selection.goaddedView File

++ package tui
++ import (
++ 	"strings"
++ 	"unicode"
++ 	"github.com/charmbracelet/x/ansi"
++ )
++ // A selection is the harness's own answer to something the terminal normally
++ // does for us. Asking for mouse reporting takes the terminal's text selection
++ // away — it stops sending drags to the clipboard and starts sending them here
++ // — so the alternative to drawing and copying a selection ourselves is not
++ // having one at all.
++ //
++ // Coordinates are content cells, not screen cells: a line is an index into
++ // the transcript's rendered rows and a column is a display cell within that
++ // row. That is what lets a selection survive scrolling and a streaming turn,
++ // which only ever append rows below it.
++ // cell is one position in the rendered transcript.
++ type cell struct{ line, col int }
++ // before reports whether c comes earlier in reading order than d.
++ func (c cell) before(d cell) bool {
++ 	return c.line < d.line || (c.line == d.line && c.col < d.col)
++ }
++ // selMode is how much of the text a drag takes: what the pointer covers,
++ // whole words, or whole lines. Double- and triple-clicks pick the wider two.
++ type selMode int
++ const (
++ 	selChar selMode = iota
++ 	selWord
++ 	selLine
++ )
++ // selection is the span the mouse has marked out.
++ type selection struct {
++ 	anchor cell // where the drag started
++ 	cursor cell // where the pointer is now
++ 	mode   selMode
++ 	// on means there is a span to paint and copy. A press alone does not set
++ 	// it: a click is how you dismiss a selection, so it takes movement — or a
++ 	// double-click, which selects a word without any — to make one.
++ 	on bool
++ 	// drag means the button is still down, so motion belongs to this
++ 	// selection rather than being stray movement after a release.
++ 	drag bool
++ }
++ // press starts a selection at c. shift keeps the existing anchor, which is
++ // how a click extends a selection rather than replacing it.
++ func (s *selection) press(c cell, shift bool) {
++ 	if shift && (s.on || s.drag) {
++ 		s.cursor, s.drag = c, true
++ 		s.on = true
++ 		return
++ 	}
++ 	s.anchor, s.cursor = c, c
++ 	s.mode, s.on, s.drag = selChar, false, true
++ }
++ // to moves the pointer while the button is down. The first movement is what
++ // turns a press into a selection.
++ func (s *selection) to(c cell) {
++ 	if !s.drag {
++ 		return
++ 	}
++ 	s.cursor = c
++ 	if c != s.anchor || s.mode != selChar {
++ 		s.on = true
++ 	}
++ }
++ // release ends the drag, leaving the span on screen to be copied.
++ func (s *selection) release() { s.drag = false }
++ // widen is what a second or third click on the same cell does.
++ func (s *selection) widen(mode selMode) {
++ 	s.mode, s.on = mode, true
++ }
++ func (s *selection) clear() { *s = selection{} }
++ // span resolves the selection against the lines it was made over: a pair of
++ // cells in reading order, the second exclusive, with the mode applied. It
++ // reports false when there is nothing to paint.
++ //
++ // The cell the drag started on is inside the span whichever way the hand
++ // moved, which is what a terminal does and what makes dragging one character
++ // to the right select that character rather than nothing.
++ func (s selection) span(lines []string) (from, to cell, ok bool) {
++ 	if !s.on || len(lines) == 0 {
++ 		return cell{}, cell{}, false
++ 	}
++ 	from, to = s.anchor, s.cursor
++ 	if to.before(from) {
++ 		from, to = to, from
++ 	}
++ 	from.line, to.line = clampLine(from.line, lines), clampLine(to.line, lines)
++ 	switch s.mode {
++ 	case selLine:
++ 		from.col, to.col = 0, lineWidth(lines, to.line)
++ 	case selWord:
++ 		from.col = wordStart(lines[from.line], from.col)
++ 		to.col = wordEnd(lines[to.line], to.col)
++ 	default:
++ 		// The cursor's own cell is taken, not just the ground it passed over.
++ 		to.col++
++ 	}
++ 	from.col = maxInt(0, from.col)
++ 	to.col = minInt(to.col, lineWidth(lines, to.line))
++ 	if from.line == to.line && to.col <= from.col {
++ 		return cell{}, cell{}, false
++ 	}
++ 	return from, to, true
++ }
++ // selectedText is what the selection puts on the clipboard: the marked cells
++ // with their styling stripped, and without the padding the viewport adds to
++ // square off a line — nobody means to copy twenty trailing spaces.
++ func selectedText(lines []string, from, to cell) string {
++ 	if from.line > to.line || len(lines) == 0 {
++ 		return ""
++ 	}
++ 	var out []string
++ 	for i := from.line; i <= to.line && i < len(lines); i++ {
++ 		plain := ansi.Strip(lines[i])
++ 		start, end := 0, ansi.StringWidth(plain)
++ 		if i == from.line {
++ 			start = from.col
++ 		}
++ 		if i == to.line {
++ 			end = minInt(end, to.col)
++ 		}
++ 		if end <= start {
++ 			out = append(out, "")
++ 			continue
++ 		}
++ 		out = append(out, strings.TrimRight(ansi.Cut(plain, start, end), " "))
++ 	}
++ 	return strings.Join(out, "\n")
++ }
++ // paintSelection draws the span over the rows the viewport is showing. It
++ // works on the viewport's own output rather than on the scrollback, so the
++ // cost is the height of the screen and the transcript's render cache — the one
++ // thing a streaming turn hits hardest — is never touched.
++ //
++ // top is the content line the first visible row holds.
++ func paintSelection(view string, top int, from, to cell) string {
++ 	rows := strings.Split(view, "\n")
++ 	for i := range rows {
++ 		line := top + i
++ 		if line < from.line || line > to.line {
++ 			continue
++ 		}
++ 		start, end := 0, ansi.StringWidth(ansi.Strip(rows[i]))
++ 		if line == from.line {
++ 			start = from.col
++ 		}
++ 		if line == to.line {
++ 			end = minInt(end, to.col)
++ 		}
++ 		rows[i] = paintRow(rows[i], start, end)
++ 	}
++ 	return strings.Join(rows, "\n")
++ }
++ // paintRow puts the selection colour behind cells [start, end) of one row.
++ //
++ // The marked cells are stripped before they are restyled. A style nested
++ // inside a background ends with a reset, which would drop the background for
++ // the rest of the span and tear a hole in it — the same trap the context pill
++ // documents, and far more visible across a whole line of syntax-highlighted
++ // code.
++ func paintRow(row string, start, end int) string {
++ 	if end <= start {
++ 		return row
++ 	}
++ 	marked := ansi.Strip(ansi.Cut(row, start, end))
++ 	if marked == "" {
++ 		return row
++ 	}
++ 	return ansi.Truncate(row, start, "") + stySelect.Render(marked) + ansi.TruncateLeft(row, end, "")
++ }
++ func clampLine(line int, lines []string) int {
++ 	return maxInt(0, minInt(line, len(lines)-1))
++ }
++ func lineWidth(lines []string, line int) int {
++ 	if line < 0 || line >= len(lines) {
++ 		return 0
++ 	}
++ 	return ansi.StringWidth(ansi.Strip(lines[line]))
++ }
++ // wordRune says which characters hang together as one word. It is wider than
++ // a letter test on purpose: the strings worth double-clicking in a transcript
++ // are paths, ids and flags, and a word rule that stops at the first slash
++ // makes picking "internal/tui/model.go:222" out of a tool result impossible.
++ func wordRune(r rune) bool {
++ 	if unicode.IsLetter(r) || unicode.IsDigit(r) {
++ 		return true
++ 	}
++ 	return strings.ContainsRune("_-./~@:+=", r)
++ }
++ // wordStart and wordEnd grow a column out to the bounds of the word under it,
++ // in columns. A column on a space takes just that space, so a double-click in
++ // the gutter selects nothing surprising.
++ //
++ // The two go through cells rather than runes because a column is a display
++ // cell: every wide character to the left of the pointer moves the rune the
++ // pointer is over one further along.
++ func wordStart(row string, col int) int {
++ 	cells := rowCells(row)
++ 	i := cellIndex(cells, col)
++ 	if i >= len(cells) || !wordRune(cells[i]) {
++ 		return col
++ 	}
++ 	for i > 0 && wordRune(cells[i-1]) {
++ 		i--
++ 	}
++ 	return cellColumn(cells, i)
++ }
++ func wordEnd(row string, col int) int {
++ 	cells := rowCells(row)
++ 	i := cellIndex(cells, col)
++ 	if i >= len(cells) || !wordRune(cells[i]) {
++ 		return col + 1
++ 	}
++ 	for i+1 < len(cells) && wordRune(cells[i+1]) {
++ 		i++
++ 	}
++ 	return cellColumn(cells, i) + runeWidth(cells[i])
++ }
++ // rowCells is a row as the runes it is made of, with its styling stripped.
++ func rowCells(row string) []rune { return []rune(ansi.Strip(row)) }
++ // cellIndex is which rune occupies a column, and cellColumn is the column a
++ // rune starts at: the two directions of the same walk along the row.
++ func cellIndex(cells []rune, col int) int {
++ 	w := 0
++ 	for i, r := range cells {
++ 		if col < w+runeWidth(r) {
++ 			return i
++ 		}
++ 		w += runeWidth(r)
++ 	}
++ 	return len(cells)
++ }
++ func cellColumn(cells []rune, idx int) int {
++ 	w := 0
++ 	for i, r := range cells {
++ 		if i >= idx {
++ 			break
++ 		}
++ 		w += runeWidth(r)
++ 	}
++ 	return w
++ }
++ func runeWidth(r rune) int { return maxInt(1, ansi.StringWidth(string(r))) }

+175−0internal/tui/selection_test.goaddedView File

++ package tui
++ import (
++ 	"strings"
++ 	"testing"
++ )
++ // The lines a selection is made over are the transcript's own rendered rows,
++ // padded to the width by the viewport, which is why trailing space is never
++ // part of what a person meant to take.
++ var selLines = []string{
++ 	"the quick brown fox      ",
++ 	"jumps over                ",
++ 	"the lazy dog             ",
++ }
++ func TestSelectedTextTakesExactlyTheMarkedCells(t *testing.T) {
++ 	cases := []struct {
++ 		name     string
++ 		from, to cell
++ 		want     string
++ 	}{
++ 		{"a word inside one line", cell{0, 4}, cell{0, 9}, "quick"},
++ 		{"to the end of a line drops the padding", cell{0, 16}, cell{0, 25}, "fox"},
++ 		{"across three lines keeps the middle whole", cell{0, 16}, cell{2, 8},
++ 			"fox\njumps over\nthe lazy"},
++ 		{"a single cell", cell{2, 4}, cell{2, 5}, "l"},
++ 		{"an empty span takes nothing", cell{1, 3}, cell{1, 3}, ""},
++ 	}
++ 	for _, tc := range cases {
++ 		if got := selectedText(selLines, tc.from, tc.to); got != tc.want {
++ 			t.Errorf("%s: selectedText = %q, want %q", tc.name, got, tc.want)
++ 		}
++ 	}
++ }
++ // What reaches the clipboard is text, not the escape sequences that coloured
++ // it on screen.
++ func TestSelectedTextCarriesNoStyling(t *testing.T) {
++ 	forceColour(t)
++ 	lines := []string{styCoral.Render("ReadFile") + styDim.Render("(path=x)")}
++ 	got := selectedText(lines, cell{0, 0}, cell{0, 16})
++ 	if got != "ReadFile(path=x)" {
++ 		t.Fatalf("selectedText = %q, want %q", got, "ReadFile(path=x)")
++ 	}
++ 	if strings.ContainsRune(got, 0x1b) {
++ 		t.Errorf("copied text still carries escape sequences: %q", got)
++ 	}
++ }
++ // A drag runs in whichever direction the hand moves, and the cell the drag
++ // started on belongs to the selection either way.
++ func TestSpanNormalisesTheDirectionOfADrag(t *testing.T) {
++ 	forward := selection{anchor: cell{0, 4}, cursor: cell{1, 2}, on: true}
++ 	from, to, ok := forward.span(selLines)
++ 	if !ok || from != (cell{0, 4}) || to != (cell{1, 3}) {
++ 		t.Errorf("dragging down: span = %v..%v (ok=%v), want {0 4}..{1 3}", from, to, ok)
++ 	}
++ 	backward := selection{anchor: cell{1, 2}, cursor: cell{0, 4}, on: true}
++ 	from, to, ok = backward.span(selLines)
++ 	if !ok || from != (cell{0, 4}) || to != (cell{1, 3}) {
++ 		t.Errorf("dragging up: span = %v..%v (ok=%v), want {0 4}..{1 3}", from, to, ok)
++ 	}
++ 	var idle selection
++ 	if _, _, ok := idle.span(selLines); ok {
++ 		t.Error("a selection nobody made reports a span")
++ 	}
++ }
++ func TestSpanExpandsToWordsAndLines(t *testing.T) {
++ 	word := selection{anchor: cell{0, 6}, cursor: cell{0, 6}, mode: selWord, on: true}
++ 	from, to, _ := word.span(selLines)
++ 	if got := selectedText(selLines, from, to); got != "quick" {
++ 		t.Errorf("double-click inside a word took %q, want %q", got, "quick")
++ 	}
++ 	line := selection{anchor: cell{1, 3}, cursor: cell{1, 3}, mode: selLine, on: true}
++ 	from, to, _ = line.span(selLines)
++ 	if got := selectedText(selLines, from, to); got != "jumps over" {
++ 		t.Errorf("triple-click took %q, want %q", got, "jumps over")
++ 	}
++ }
++ // Double-clicking a path is how a person picks one out of a wall of tool
++ // output, so the run of characters a path is made of counts as one word.
++ func TestWordSelectionKeepsAPathWhole(t *testing.T) {
++ 	lines := []string{"edited internal/tui/model.go:222 for you"}
++ 	sel := selection{anchor: cell{0, 12}, cursor: cell{0, 12}, mode: selWord, on: true}
++ 	from, to, _ := sel.span(lines)
++ 	if got := selectedText(lines, from, to); got != "internal/tui/model.go:222" {
++ 		t.Errorf("double-click on a path took %q, want the whole path", got)
++ 	}
++ }
++ // A press alone is a click: it puts the caret somewhere and clears whatever
++ // was selected. Only movement with the button down makes a selection.
++ func TestAClickWithoutMovementSelectsNothing(t *testing.T) {
++ 	var s selection
++ 	s.press(cell{0, 4}, false)
++ 	if s.on {
++ 		t.Error("a press with no movement already counts as a selection")
++ 	}
++ 	s.to(cell{0, 9})
++ 	if !s.on {
++ 		t.Error("moving with the button down did not start a selection")
++ 	}
++ }
++ // A column is a display cell, not a rune: two of them go by for every wide
++ // character to the left of the pointer.
++ func TestWordSelectionCountsCellsNotRunes(t *testing.T) {
++ 	lines := []string{"日本語 fox"}
++ 	sel := selection{anchor: cell{0, 7}, cursor: cell{0, 7}, mode: selWord, on: true}
++ 	from, to, _ := sel.span(lines)
++ 	if got := selectedText(lines, from, to); got != "fox" {
++ 		t.Errorf("double-click past a wide rune took %q, want %q", got, "fox")
++ 	}
++ }
++ func TestPaintMarksExactlyTheSelectedCells(t *testing.T) {
++ 	forceColour(t)
++ 	view := strings.Join(selLines, "\n")
++ 	rows := strings.Split(paintSelection(view, 0, cell{0, 4}, cell{0, 9}), "\n")
++ 	if got := backedCells(rows[0]); got != "quick" {
++ 		t.Errorf("the highlight covers %q, want %q", got, "quick")
++ 	}
++ 	for _, row := range rows[1:] {
++ 		if got := backedCells(row); got != "" {
++ 			t.Errorf("a row outside the selection was painted: %q", got)
++ 		}
++ 	}
++ }
++ // The viewport hands over the rows it is showing, so which content line a row
++ // holds depends on how far the transcript has been scrolled.
++ func TestPaintFollowsTheScrollOffset(t *testing.T) {
++ 	forceColour(t)
++ 	view := strings.Join(selLines, "\n")
++ 	rows := strings.Split(paintSelection(view, 5, cell{6, 0}, cell{6, 5}), "\n")
++ 	if got := backedCells(rows[1]); got != "jumps" {
++ 		t.Errorf("row 1 with the view scrolled to line 5 shows %q, want %q", got, "jumps")
++ 	}
++ 	if got := backedCells(rows[0]) + backedCells(rows[2]); got != "" {
++ 		t.Errorf("the wrong rows were painted: %q", got)
++ 	}
++ }
++ // The text around a selection keeps the colour it had. The marked text does
++ // not: a style nested inside a background ends with a reset, which would drop
++ // the background for the rest of the span and tear a hole in it.
++ func TestPaintLeavesTheSurroundingColoursAloneAndHasNoHoles(t *testing.T) {
++ 	forceColour(t)
++ 	view := styToolName.Render("ReadFile") + styToolArgs.Render("(path=x)")
++ 	got := paintSelection(view, 0, cell{0, 0}, cell{0, 8})
++ 	if marked := backedCells(got); marked != "ReadFile" {
++ 		t.Errorf("the highlight covers %q, want %q", marked, "ReadFile")
++ 	}
++ 	if rest := unbackedCells(got); rest != "(path=x)" {
++ 		t.Errorf("outside the selection reads %q, want %q", rest, "(path=x)")
++ 	}
++ 	// Selecting the whole of a line built from several styles must come back
++ 	// as one unbroken run of marked cells.
++ 	whole := paintSelection(view, 0, cell{0, 0}, cell{0, 16})
++ 	if marked := backedCells(whole); marked != "ReadFile(path=x)" {
++ 		t.Errorf("a fully selected line is torn: marked %q", marked)
++ 	}
++ }

+6−0internal/tui/styles.goView File

@@ -27,6 +27,7 @@ var (
27	27	colWarn lipgloss.AdaptiveColor
28	28	colBlue lipgloss.AdaptiveColor
29	29	colPillBg lipgloss.AdaptiveColor
	30	+ colSelBg lipgloss.AdaptiveColor
30	31	)
31	32
32	33	var (
@@ -75,4 +76,9 @@ var (
75	76	// The approval box is the one place the UI is allowed to shout: it is the
76	77	// only moment a human has to decide something.
77	78	styModal lipgloss.Style
	79	+
	80	+ // A mouse selection. Asking for mouse reporting costs the terminal's own
	81	+ // selection, so this is the harness's replacement for it, and it has to
	82	+ // read as a selection at a glance in all four themes.
	83	+ stySelect lipgloss.Style
78	84	)

+18−3internal/tui/theme.goView File

@@ -10,9 +10,9 @@ import (
10	10	// derived from it, so a theme decides colour and nothing about layout. Adding
11	11	// one is adding an entry here and a name to config.Themes.
12	12	//
13		- // Every theme names all ten roles rather than inheriting the missing ones from
14		- // a base. Inheritance would make a half-specified theme render as a mix of two
15		- // palettes, which is the one outcome worse than an ugly theme.
	13	+ // Every theme names all eleven roles rather than inheriting the missing ones
	14	+ // from a base. Inheritance would make a half-specified theme render as a mix of
	15	+ // two palettes, which is the one outcome worse than an ugly theme.
16	16	type theme struct {
17	17	name string
18	18	// blurb is what the wizard says about it, in the wizard's own voice.
@@ -28,6 +28,10 @@ type theme struct {
28	28	warn lipgloss.AdaptiveColor
29	29	info lipgloss.AdaptiveColor
30	30	pillBg lipgloss.AdaptiveColor
	31	+ // selBg is what a mouse selection is painted on. It is a tint of the
	32	+ // theme's own accent rather than a neutral grey, so a selection cannot be
	33	+ // mistaken for the pill background the status bar already uses.
	34	+ selBg lipgloss.AdaptiveColor
31	35	}
32	36
33	37	// themes are in the order the wizard offers them; ember is first because it
@@ -50,6 +54,7 @@ var themes = []theme{{
50	54	warn: lipgloss.AdaptiveColor{Light: "#8a5a00", Dark: "#e0a458"},
51	55	info: lipgloss.AdaptiveColor{Light: "#2f5fa8", Dark: "#7aa2e3"},
52	56	pillBg: lipgloss.AdaptiveColor{Light: "#ebe7e2", Dark: "#2b2825"},
	57	+ selBg: lipgloss.AdaptiveColor{Light: "#f6d8cb", Dark: "#5c3527"},
53	58	}, {
54	59	name: "mint",
55	60	blurb: "Cool green. Easiest on a bright screen.",
@@ -63,6 +68,7 @@ var themes = []theme{{
63	68	warn: lipgloss.AdaptiveColor{Light: "#8a5a00", Dark: "#e8bc6a"},
64	69	info: lipgloss.AdaptiveColor{Light: "#2f5fa8", Dark: "#79a8d8"},
65	70	pillBg: lipgloss.AdaptiveColor{Light: "#e4ecea", Dark: "#232b29"},
	71	+ selBg: lipgloss.AdaptiveColor{Light: "#cbe8e1", Dark: "#1f4c44"},
66	72	}, {
67	73	name: "iris",
68	74	blurb: "Violet and slate. Quiet under low light.",
@@ -76,6 +82,7 @@ var themes = []theme{{
76	82	warn: lipgloss.AdaptiveColor{Light: "#8a5a00", Dark: "#e2b062"},
77	83	info: lipgloss.AdaptiveColor{Light: "#2f5fa8", Dark: "#86a8ec"},
78	84	pillBg: lipgloss.AdaptiveColor{Light: "#eae7f2", Dark: "#282434"},
	85	+ selBg: lipgloss.AdaptiveColor{Light: "#ded2f8", Dark: "#3d2f60"},
79	86	}, {
80	87	name: "mono",
81	88	blurb: "No accent hue. For screens and eyes that want none.",
@@ -93,6 +100,7 @@ var themes = []theme{{
93	100	warn: lipgloss.AdaptiveColor{Light: "#7a6030", Dark: "#c8b083"},
94	101	info: lipgloss.AdaptiveColor{Light: "#4a5f7a", Dark: "#9aaec8"},
95	102	pillBg: lipgloss.AdaptiveColor{Light: "#e9e9e9", Dark: "#2a2a2a"},
	103	+ selBg: lipgloss.AdaptiveColor{Light: "#d0d0d0", Dark: "#484848"},
96	104	}}
97	105
98	106	// defaultTheme is what an unconfigured harness looks like, and the fallback
@@ -147,6 +155,7 @@ func applyTheme(name string) {
147	155	colCoral, colText, colUser = t.accent, t.text, t.user
148	156	colDim, colFaint = t.dim, t.faint
149	157	colOK, colErr, colWarn, colBlue, colPillBg = t.ok, t.err, t.warn, t.info, t.pillBg
	158	+ colSelBg = t.selBg
150	159
151	160	styText = lipgloss.NewStyle().Foreground(colText)
152	161	styDim = lipgloss.NewStyle().Foreground(colDim)
@@ -193,6 +202,12 @@ func applyTheme(name string) {
193	202	BorderForeground(colCoral).
194	203	Padding(0, 1)
195	204
	205	+ // The foreground is named rather than inherited: the marked cells are
	206	+ // stripped of their own colour before they are painted, so whatever they
	207	+ // were — dim grey, a diff's red, a comment in a code fence — has to come
	208	+ // back as something that reads on this background.
	209	+ stySelect = lipgloss.NewStyle().Foreground(colText).Background(colSelBg)
	210	+
196	211	// Markdown is styled from the same palette, and its stylesheet is baked
197	212	// rather than read per draw, so it has to be rebuilt here too.
198	213	resetMarkdown()

+18−2internal/tui/transcript.goView File

@@ -73,7 +73,12 @@ type transcript struct {
73	73	verbose bool
74	74
75	75	cache string
76		- dirty bool
	76	+ // cacheLines is the same text split into rows, built only when something
	77	+ // asks — which is the mouse, and only while it is being used. A streaming
	78	+ // turn re-renders on every token and must not pay for a split nobody is
	79	+ // looking at.
	80	+ cacheLines []string
	81	+ dirty bool
77	82	// gen is the theme generation the cache was built under.
78	83	gen int
79	84	}
@@ -217,10 +222,21 @@ func (t *transcript) render() string {
217	222	}
218	223	b.WriteString(t.renderEntry(&t.entries[i]))
219	224	}
220		- t.cache, t.dirty = b.String(), false
	225	+ t.cache, t.cacheLines, t.dirty = b.String(), nil, false
221	226	return t.cache
222	227	}
223	228
	229	+ // lines is the scrollback as the viewport holds it: one string per row. It is
	230	+ // the coordinate system a mouse selection is made in — a row here is a row on
	231	+ // screen once the viewport's scroll offset is taken off.
	232	+ func (t *transcript) lines() []string {
	233	+ s := t.render()
	234	+ if t.cacheLines == nil {
	235	+ t.cacheLines = strings.Split(s, "\n")
	236	+ }
	237	+ return t.cacheLines
	238	+ }
	239	+
224	240	// renderEntry draws one entry. It takes a pointer because an assistant entry
225	241	// keeps its laid-out Markdown rather than producing it again every frame.
226	242	func (t transcript) renderEntry(e entry) string {