johannSoCodeyPublic

tui: /effort is a slider, not a level you have to remember

Bare /effort now swaps the prompt for a track with the five levels spread
across it, Faster to Smarter, the marker starting on the level in force —
which for an unset level is high, the API's own default, rather than an end
of the track nobody chose. Arrows move, 1-5 jump, enter applies, esc leaves
it alone; moving the marker on its own changes nothing.

The alignment of the marker over its label is the whole illusion, so the
track is built as plain runes and painted afterwards, and a test walks every
level at three widths checking the marker lands inside the label's cells.
Below about forty columns the labels cannot be laid out with room to breathe,
and a slider with the words sliced in half is worse than "◀ high ▶", so that
is what a narrow terminal gets.

/effort xhigh still applies directly: the picker is for choosing, not a toll
booth on a level you already know.

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

Browse Files

Jjonicommitted 4 weeks ago1 parent 32a55c5commit37f21fd

Showing 6 changed files with 438 additions and 51 deletions.

+17−3README.mdView File

@@ -102,9 +102,23 @@ level for `/effort` — and `esc` dismisses the menu without touching what you
102	102	typed. The menu offers exactly the commands the TUI answers, so nothing it
103	103	suggests can come back as "unknown command".
104	104
105		- `/effort` reports the levels and marks the one in force; `/effort xhigh` changes
106		- it for the turns that follow, which is the `-effort` flag reached from the
107		- keyboard. The setting shows above the prompt on the right.
	105	+ `/effort` opens a slider in place of the prompt, on the level in force — an
	106	+ unset level is the API's own default, `high`, so the marker starts there rather
	107	+ than at an end:
	108	+
	109	+ ```
	110	+ Faster Smarter
	111	+ ──────────────────────────────────────▲───────────────────────────────────
	112	+ low medium high xhigh max
	113	+ ←→ move · 1-5 jump · enter apply · esc cancel
	114	+ ```
	115	+
	116	+ Moving the marker changes nothing until `enter`; `esc` leaves the level alone.
	117	+ `/effort xhigh` still applies a level directly for anyone who can type it, and
	118	+ either way it is the `-effort` flag reached from the keyboard. The level in
	119	+ force shows above the prompt on the right. A terminal too narrow for five
	120	+ labels gets `◀ high ▶` and the same keys rather than a track with the words
	121	+ sliced in half.
108	122
109	123	`shift+tab` cycles between asking before every mutating call and accepting them
110	124	all, which is `-yolo` reached from the keyboard. The mode line says which is in

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

@@ -23,7 +23,7 @@ type command struct {
23	23	var builtins = []command{
24	24	{name: "help", desc: "the commands and the keys"},
25	25	{name: "skills", desc: "the instruction sets found at startup"},
26		- {name: "effort", args: "level", desc: "how hard the model thinks: low … max"},
	26	+ {name: "effort", args: "level", desc: "how hard the model thinks — opens a slider"},
27	27	{name: "clear", desc: "empty the transcript"},
28	28	{name: "allowed", desc: "what is permanently allowed this session"},
29	29	{name: "exit", desc: "leave the harness"},

+152−0internal/tui/effort.goaddedView File

++ package tui
++ import (
++ 	"strings"
++ 	"github.com/charmbracelet/bubbles/textarea"
++ 	tea "github.com/charmbracelet/bubbletea"
++ 	"github.com/charmbracelet/lipgloss"
++ 	"harness/internal/llm"
++ )
++ // defaultEffort is where the marker sits when nothing has been chosen. The
++ // API's own default is high, so an unset level is not "no level": it is that
++ // one, and the slider says so rather than starting at an end.
++ const defaultEffort = "high"
++ // openEffort puts the slider on screen, on the level currently in force.
++ func (m *model) openEffort() tea.Cmd {
++ 	m.effortIdx = effortIndex(m.opts.Effort)
++ 	m.phase = phaseEffort
++ 	m.closeMenu()
++ 	return m.sync()
++ }
++ func effortIndex(level string) int {
++ 	if level == "" {
++ 		level = defaultEffort
++ 	}
++ 	for i, l := range llm.EffortLevels {
++ 		if l == level {
++ 			return i
++ 		}
++ 	}
++ 	return effortIndex("")
++ }
++ // onEffortKey drives the slider. It answers every key while the slider is up:
++ // there is no prompt behind it to type into, so nothing falls through.
++ func (m *model) onEffortKey(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
++ 	last := len(llm.EffortLevels) - 1
++ 	switch key := msg.String(); key {
++ 	case "left", "ctrl+b":
++ 		// A slider has ends. Running past one holds rather than wrapping,
++ 		// which would put max one keypress to the left of low.
++ 		m.effortIdx = maxInt(0, m.effortIdx-1)
++ 	case "right", "ctrl+f":
++ 		m.effortIdx = minInt(last, m.effortIdx+1)
++ 	case "home":
++ 		m.effortIdx = 0
++ 	case "end":
++ 		m.effortIdx = last
++ 	case "enter", "tab":
++ 		m.phase = phaseIdle
++ 		m.applyEffort(llm.EffortLevels[m.effortIdx])
++ 		return m, tea.Batch(m.sync(), textarea.Blink)
++ 	case "esc", "ctrl+c":
++ 		m.phase = phaseIdle
++ 		return m, tea.Batch(m.sync(), textarea.Blink)
++ 	default:
++ 		// 1 through 5 jump straight to a level. A digit past the last one is
++ 		// not a level, so it does nothing rather than clamping to an end the
++ 		// user did not aim at.
++ 		if len(key) == 1 && key[0] >= '1' && key[0] <= '9' {
++ 			if i := int(key[0] - '1'); i <= last {
++ 				m.effortIdx = i
++ 			}
++ 		}
++ 	}
++ 	return m, m.sync()
++ }
++ // applyEffort records the level, tells the agent, and says so in the
++ // transcript. The agent is nil in tests; the level still takes, because the
++ // chrome reads it from here.
++ func (m *model) applyEffort(level string) {
++ 	m.opts.Effort = level
++ 	if m.opts.Agent != nil {
++ 		m.opts.Agent.SetEffort(level)
++ 	}
++ 	m.tr.addNotice("effort: " + level + " — from the next turn on")
++ }
++ // effortView is the slider: the poles, the track with the marker riding it,
++ // the labels under it, and the keys that drive it.
++ //
++ //	Faster                                                    Smarter
++ //	─────────────────────────────▲───────────────────────────────────
++ //	  low          medium         high          xhigh          max
++ func (m *model) effortView() string {
++ 	width := maxInt(1, m.width)
++ 	starts := effortSlots(width - 1)
++ 	if starts == nil {
++ 		// Too narrow for a track. The level and the keys still fit, and they
++ 		// are the part that does the work.
++ 		level := llm.EffortLevels[m.effortIdx]
++ 		compact := styFaint.Render("◀ ") + styKey.Render(level) + styFaint.Render(" ▶")
++ 		return truncateStyled(" "+compact, width) + "\n" +
++ 			truncateStyled(" "+styFaint.Render("enter apply · esc cancel"), width)
++ 	}
++ 	// The track is plain runes until the marker is placed on it, so the
++ 	// marker's column is arithmetic rather than a sum of escape sequences.
++ 	track := []rune(strings.Repeat("─", width-1))
++ 	var labels strings.Builder
++ 	col := 0
++ 	for i, level := range llm.EffortLevels {
++ 		if gap := starts[i] - col; gap > 0 {
++ 			labels.WriteString(strings.Repeat(" ", gap))
++ 			col += gap
++ 		}
++ 		style := styDim
++ 		if i == m.effortIdx {
++ 			style = styKey
++ 			track[starts[i]+lipgloss.Width(level)/2] = '▲'
++ 		}
++ 		labels.WriteString(style.Render(level))
++ 		col += lipgloss.Width(level)
++ 	}
++ 	return spread(styDim.Render("Faster"), styDim.Render("Smarter"), width) + "\n" +
++ 		" " + styFaint.Render(string(track)) + "\n" +
++ 		" " + labels.String() + "\n" +
++ 		truncateStyled(" "+styFaint.Render("←→ move · 1-5 jump · enter apply · esc cancel"), width)
++ }
++ // effortSlots is the column each label starts at, spread evenly across width.
++ // It returns nil when the labels cannot be laid out with room to breathe,
++ // which is the caller's cue to render something simpler.
++ func effortSlots(width int) []int {
++ 	n := len(llm.EffortLevels)
++ 	longest := 0
++ 	for _, l := range llm.EffortLevels {
++ 		longest = maxInt(longest, lipgloss.Width(l))
++ 	}
++ 	slot := width / n
++ 	if slot < longest+2 {
++ 		return nil
++ 	}
++ 	starts := make([]int, n)
++ 	for i, l := range llm.EffortLevels {
++ 		starts[i] = i*slot + (slot-lipgloss.Width(l))/2
++ 	}
++ 	return starts
++ }

+245−0internal/tui/effort_test.goaddedView File

++ package tui
++ import (
++ 	"strings"
++ 	"testing"
++ 	tea "github.com/charmbracelet/bubbletea"
++ 	"harness/internal/llm"
++ )
++ // levelAt is where a level sits on the track, so tests can talk about
++ // positions without hard-coding the order.
++ func levelAt(name string) int {
++ 	for i, l := range llm.EffortLevels {
++ 		if l == name {
++ 			return i
++ 		}
++ 	}
++ 	return -1
++ }
++ // runeIndex is strings.Index counted in cells rather than in bytes.
++ func runeIndex(haystack, needle string) int {
++ 	i := strings.Index(haystack, needle)
++ 	if i < 0 {
++ 		return -1
++ 	}
++ 	return len([]rune(haystack[:i]))
++ }
++ // Bare /effort opens the slider on the level in force. Unset is not "nothing
++ // selected": the API's default is high, and that is where the marker belongs.
++ func TestEffortPickerOpensOnTheLevelInForce(t *testing.T) {
++ 	for _, tc := range []struct{ effort, want string }{
++ 		{"", "high"},
++ 		{"low", "low"},
++ 		{"max", "max"},
++ 	} {
++ 		m := newTestModel(t)
++ 		m.opts.Effort = tc.effort
++ 		m.submit("/effort")
++ 		if m.phase != phaseEffort {
++ 			t.Fatalf("effort %q: phase = %v, want the picker open", tc.effort, m.phase)
++ 		}
++ 		if got := llm.EffortLevels[m.effortIdx]; got != tc.want {
++ 			t.Errorf("effort %q: marker on %q, want %q", tc.effort, got, tc.want)
++ 		}
++ 	}
++ }
++ // It is a slider, so the ends are ends: moving past one stays put rather than
++ // wrapping around to the opposite extreme.
++ func TestEffortPickerMovesAndClampsAtTheEnds(t *testing.T) {
++ 	m := newTestModel(t)
++ 	m.opts.Effort = "high"
++ 	m.submit("/effort")
++ 	m.Update(key("right"))
++ 	if got := m.effortIdx; got != levelAt("xhigh") {
++ 		t.Errorf("right put the marker on %q", llm.EffortLevels[got])
++ 	}
++ 	m.Update(key("left"))
++ 	m.Update(key("left"))
++ 	if got := m.effortIdx; got != levelAt("medium") {
++ 		t.Errorf("two lefts put the marker on %q", llm.EffortLevels[got])
++ 	}
++ 	for i := 0; i < 5; i++ {
++ 		m.Update(key("left"))
++ 	}
++ 	if got := m.effortIdx; got != 0 {
++ 		t.Errorf("marker ran off the cheap end to %d", got)
++ 	}
++ 	for i := 0; i < 9; i++ {
++ 		m.Update(key("right"))
++ 	}
++ 	if got, want := m.effortIdx, len(llm.EffortLevels)-1; got != want {
++ 		t.Errorf("marker = %d, want it held at %d", got, want)
++ 	}
++ }
++ func TestEffortPickerNumbersJumpToALevel(t *testing.T) {
++ 	m := newTestModel(t)
++ 	m.submit("/effort")
++ 	m.Update(key("1"))
++ 	if got := llm.EffortLevels[m.effortIdx]; got != "low" {
++ 		t.Errorf("1 selected %q, want low", got)
++ 	}
++ 	m.Update(key("5"))
++ 	if got := llm.EffortLevels[m.effortIdx]; got != "max" {
++ 		t.Errorf("5 selected %q, want max", got)
++ 	}
++ 	// There is no sixth level; the key is not a level, so nothing moves.
++ 	m.Update(key("6"))
++ 	if got := llm.EffortLevels[m.effortIdx]; got != "max" {
++ 		t.Errorf("6 moved the marker to %q", got)
++ 	}
++ }
++ // Moving the marker changes nothing until enter; enter closes the picker and
++ // the level takes.
++ func TestEffortPickerAppliesOnEnter(t *testing.T) {
++ 	m := newTestModel(t)
++ 	m.opts.Effort = "high"
++ 	m.submit("/effort")
++ 	m.Update(key("right"))
++ 	if m.opts.Effort != "high" {
++ 		t.Errorf("effort = %q — moving the marker must not change anything", m.opts.Effort)
++ 	}
++ 	m.Update(key("enter"))
++ 	if m.opts.Effort != "xhigh" {
++ 		t.Errorf("effort = %q, want xhigh", m.opts.Effort)
++ 	}
++ 	if m.phase != phaseIdle {
++ 		t.Errorf("phase = %v after applying, want the prompt back", m.phase)
++ 	}
++ 	if !strings.Contains(m.tr.render(), "xhigh") {
++ 		t.Error("the change was not reported in the transcript")
++ 	}
++ 	if !strings.Contains(m.activity(), "xhigh") {
++ 		t.Error("the effort pill did not follow")
++ 	}
++ }
++ func TestEffortPickerCancelsOnEscape(t *testing.T) {
++ 	m := newTestModel(t)
++ 	m.opts.Effort = "low"
++ 	m.submit("/effort")
++ 	m.Update(key("right"))
++ 	m.Update(key("esc"))
++ 	if m.opts.Effort != "low" {
++ 		t.Errorf("effort = %q, want the level left alone", m.opts.Effort)
++ 	}
++ 	if m.phase != phaseIdle {
++ 		t.Errorf("phase = %v after cancelling, want the prompt back", m.phase)
++ 	}
++ }
++ // Typing the level is still the fast path: it applies without a picker to
++ // dismiss.
++ func TestTypedLevelSkipsThePicker(t *testing.T) {
++ 	m := newTestModel(t)
++ 	m.submit("/effort max")
++ 	if m.phase != phaseIdle {
++ 		t.Errorf("phase = %v, want no picker for a level that was typed out", m.phase)
++ 	}
++ 	if m.opts.Effort != "max" {
++ 		t.Errorf("effort = %q, want max", m.opts.Effort)
++ 	}
++ }
++ // The marker has to sit over the label it selects — that alignment is the
++ // whole illusion of a slider.
++ func TestSliderMarkerSitsOverTheSelectedLabel(t *testing.T) {
++ 	for _, width := range []int{60, 80, 120} {
++ 		for i, level := range llm.EffortLevels {
++ 			m := newTestModel(t)
++ 			m.Update(tea.WindowSizeMsg{Width: width, Height: 30})
++ 			m.submit("/effort")
++ 			m.effortIdx = i
++ 			lines := strings.Split(m.effortView(), "\n")
++ 			if len(lines) < 4 {
++ 				t.Fatalf("width %d: the slider is %d lines: %q", width, len(lines), lines)
++ 			}
++ 			// Columns are cells, not bytes: the track is drawn in box
++ 			// characters that are three bytes each.
++ 			track, labels := lines[1], lines[2]
++ 			marker := runeIndex(track, "▲")
++ 			if marker < 0 {
++ 				t.Fatalf("width %d: no marker on the track %q", width, track)
++ 			}
++ 			start := runeIndex(labels, level)
++ 			if start < 0 {
++ 				t.Fatalf("width %d: %q missing from the labels %q", width, level, labels)
++ 			}
++ 			if marker < start || marker >= start+len(level) {
++ 				t.Errorf("width %d, %s: marker at column %d, label spans %d-%d\n%s\n%s",
++ 					width, level, marker, start, start+len(level)-1, track, labels)
++ 			}
++ 		}
++ 	}
++ }
++ func TestSliderShowsEveryLevelAndItsPoles(t *testing.T) {
++ 	m := newTestModel(t)
++ 	m.Update(tea.WindowSizeMsg{Width: 80, Height: 30})
++ 	m.submit("/effort")
++ 	view := m.effortView()
++ 	for _, want := range append([]string{"Faster", "Smarter", "enter", "esc"}, llm.EffortLevels...) {
++ 		if !strings.Contains(view, want) {
++ 			t.Errorf("%q missing from the slider:\n%s", want, view)
++ 		}
++ 	}
++ }
++ // A terminal too narrow for five labels gets the level and the keys rather
++ // than a track with the words sliced in half.
++ func TestSliderFallsBackOnANarrowTerminal(t *testing.T) {
++ 	m := newTestModel(t)
++ 	m.Update(tea.WindowSizeMsg{Width: 30, Height: 20})
++ 	m.opts.Effort = "xhigh"
++ 	m.submit("/effort")
++ 	view := m.effortView()
++ 	if !strings.Contains(view, "xhigh") {
++ 		t.Errorf("the selected level is missing:\n%s", view)
++ 	}
++ 	if strings.Contains(view, "medium") {
++ 		t.Errorf("a label that cannot fit was rendered anyway:\n%s", view)
++ 	}
++ 	for _, line := range strings.Split(view, "\n") {
++ 		if len(line) > 30 {
++ 			t.Errorf("line is %d cells wide on a 30-cell terminal: %q", len(line), line)
++ 		}
++ 	}
++ 	if got := strings.Count(m.View(), "\n") + 1; got > 20 {
++ 		t.Errorf("the screen is %d lines on a 20-line terminal", got)
++ 	}
++ }
++ // While the picker owns the screen there is no prompt to type into, so keys
++ // that are not its own must not leak into the textarea.
++ func TestPickerSwallowsTyping(t *testing.T) {
++ 	m := newTestModel(t)
++ 	m.submit("/effort")
++ 	typeIn(m, "hello")
++ 	if got := m.input.Value(); got != "" {
++ 		t.Errorf("input = %q, want the picker to have eaten those keys", got)
++ 	}
++ 	if m.phase != phaseEffort {
++ 		t.Errorf("phase = %v, want the picker still open", m.phase)
++ 	}
++ }

+19−28internal/tui/model.goView File

@@ -53,6 +53,9 @@ const (
53	53	phaseIdle phase = iota
54	54	phaseRunning
55	55	phaseApproving
	56	+ // phaseEffort is the effort slider: the prompt is gone until a level is
	57	+ // picked or the slider is dismissed.
	58	+ phaseEffort
56	59	)
57	60
58	61	// inputMaxLines caps how far the prompt box grows before it scrolls. Past
@@ -91,6 +94,9 @@ type model struct {
91	94	// menu is the slash-command completion list under the prompt.
92	95	menu menu
93	96
	97	+ // effortIdx is where the marker sits while the effort slider is up.
	98	+ effortIdx int
	99	+
94	100	// pending approvals. The agent blocks on one at a time, but a queue costs
95	101	// nothing and means a second request can never be dropped.
96	102	pending []approvalMsg
@@ -333,6 +339,9 @@ func (m *model) onKey(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
333	339	if m.phase == phaseApproving {
334	340	return m.onApprovalKey(msg)
335	341	}
	342	+ if m.phase == phaseEffort {
	343	+ return m.onEffortKey(msg)
	344	+ }
336	345
337	346	// An open menu owns the keys that drive it — including enter and esc,
338	347	// which mean something else the rest of the time.
@@ -491,42 +500,21 @@ func (m *model) submit(line string) (tea.Model, tea.Cmd) {
491	500	return m, tea.Batch(m.sync(), m.spin.Tick, m.runTurn(line))
492	501	}
493	502
494		- // setEffort answers /effort. Bare, it reports the levels and marks the one in
495		- // force; with a level, it changes what the turns that follow ask for.
	503	+ // setEffort answers /effort. Bare, it opens the slider; with a level, it
	504	+ // applies it directly, which is the fast path for anyone who knows what they
	505	+ // want and can type it.
496	506	func (m *model) setEffort(level string) tea.Cmd {
497	507	switch {
498	508	case level == "":
499		- m.tr.addNotice("effort: " + effortListing(m.opts.Effort))
	509	+ return m.openEffort()
500	510	case !llm.ValidEffort(level):
501	511	m.tr.addError("unknown effort " + level + " — one of " + strings.Join(llm.EffortLevels, ", "))
502	512	default:
503		- m.opts.Effort = level
504		- if m.opts.Agent != nil {
505		- m.opts.Agent.SetEffort(level)
506		- }
507		- m.tr.addNotice("effort: " + level + " — from the next turn on")
	513	+ m.applyEffort(level)
508	514	}
509	515	return m.sync()
510	516	}
511	517
512		- // effortListing names the levels and marks the current one. An empty current
513		- // level is the API's own default rather than a level this harness picked, and
514		- // it says so instead of silently marking nothing.
515		- func effortListing(current string) string {
516		- parts := make([]string, 0, len(llm.EffortLevels))
517		- for _, l := range llm.EffortLevels {
518		- if l == current {
519		- l = "● " + l
520		- }
521		- parts = append(parts, l)
522		- }
523		- out := strings.Join(parts, " ")
524		- if current == "" {
525		- out += " (the API default until you pick one)"
526		- }
527		- return out
528		- }
529		-
530	518	// isSkill reports whether a slash command names a discovered skill. Matching
531	519	// here rather than sending every unrecognised slash to the model means a typo
532	520	// is caught by the harness instead of puzzled over by the agent.
@@ -653,9 +641,12 @@ func (m *model) View() string {
653	641	func (m *model) bottom() string {
654	642	var b strings.Builder
655	643	b.WriteString(m.activity() + "\n")
656		- if m.phase == phaseApproving && len(m.pending) > 0 {
	644	+ switch {
	645	+ case m.phase == phaseApproving && len(m.pending) > 0:
657	646	b.WriteString(m.approvalView() + "\n")
658		- } else {
	647	+ case m.phase == phaseEffort:
	648	+ b.WriteString(m.effortView() + "\n")
	649	+ default:
659	650	b.WriteString(m.inputBox() + "\n")
660	651	if v := m.menuView(); v != "" {
661	652	b.WriteString(v + "\n")

+4−19internal/tui/model_test.goView File

@@ -43,6 +43,10 @@ func key(s string) tea.KeyMsg {
43	43	return tea.KeyMsg{Type: tea.KeyUp}
44	44	case "down":
45	45	return tea.KeyMsg{Type: tea.KeyDown}
	46	+ case "left":
	47	+ return tea.KeyMsg{Type: tea.KeyLeft}
	48	+ case "right":
	49	+ return tea.KeyMsg{Type: tea.KeyRight}
46	50	}
47	51	return tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune(s)}
48	52	}
@@ -465,22 +469,3 @@ func TestEffortCommandRejectsAnUnknownLevel(t *testing.T) {
465	469	t.Error("a rejected effort still started a turn")
466	470	}
467	471	}
468		-
469		- func TestBareEffortReportsTheLevelsAndTheCurrentOne(t *testing.T) {
470		- m := newTestModel(t)
471		- m.opts.Effort = "medium"
472		- m.submit("/effort")
473		-
474		- out := m.tr.render()
475		- for _, level := range llm.EffortLevels {
476		- if !strings.Contains(out, level) {
477		- t.Errorf("level %q missing from %q", level, out)
478		- }
479		- }
480		- if !strings.Contains(out, "● medium") {
481		- t.Errorf("the level in force is not marked: %q", out)
482		- }
483		- if m.phase != phaseIdle {
484		- t.Error("asking about effort started a turn")
485		- }
486		- }