johannSoCodeyPublic

tui: a completion menu for slash commands, and a working /effort

Typing a slash at the start of an empty prompt now opens a menu of every
command the TUI answers — the built-ins and one row per discovered skill —
filtered as you type, prefix matches ahead of substring ones. Up and down
move, tab or enter completes into the prompt box, esc dismisses without
touching what was typed. Completing is not sending: a skill and /effort both
take arguments, and a menu that fired the command on enter would leave
nowhere to type them.

The menu, /help and the unknown-command check all read one catalogue, so the
menu cannot advertise a command that comes back as "unknown command" — there
is a test that walks the catalogue through submit to keep it that way.

/effort was advertised above the prompt but never implemented. It is now:
bare it reports the levels and marks the one in force, with a level it
changes what the following turns ask for. The agent grows SetEffort for it,
guarded by a mutex because the loop reads the level on its own goroutine.

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

Browse Files

Jjonicommitted 4 weeks ago1 parent f04f191commit32a55c5

Showing 10 changed files with 708 additions and 9 deletions.

+26−1README.mdView File

@@ -72,6 +72,7 @@ to six lines.
72	72	\| Key \| Does \|
73	73	\| --- \| --- \|
74	74	\| `enter` \| send \|
	75	+ \| `/` \| open the command menu — see below \|
75	76	\| `ctrl+j` \| newline without sending \|
76	77	\| `shift+tab` \| cycle the approval mode \|
77	78	\| `ctrl+r` \| expand elided tool output \|
@@ -79,7 +80,31 @@ to six lines.
79	80	\| `esc` \| interrupt the turn \|
80	81	\| `ctrl+c` \| interrupt the turn; again when idle to exit \|
81	82
82		- Commands: `/allowed`, `/clear`, `/help`, `/exit`, `/skills`.
	83	+ Commands: `/allowed`, `/clear`, `/effort`, `/exit`, `/help`, `/skills`, and one
	84	+ per discovered skill.
	85	+
	86	+ A slash at the start of an empty prompt opens the command menu, which filters
	87	+ as you type — a name that starts with what you typed before one that merely
	88	+ contains it:
	89	+
	90	+ ```
	91	+ ╭──────────────────────────────────────────────────────────────────────────────╮
	92	+ │ › /s │
	93	+ ╰──────────────────────────────────────────────────────────────────────────────╯
	94	+ ❯ /skills the instruction sets found at startup
	95	+ /systematic-debugging find the cause before changing code (project)
	96	+ /brainstorming explore an idea before building it (personal)
	97	+ ```
	98	+
	99	+ `↑`/`↓` move, `tab` or `enter` completes the highlighted name into the prompt —
	100	+ completing is not sending, so there is room to type arguments for a skill or a
	101	+ level for `/effort` — and `esc` dismisses the menu without touching what you
	102	+ typed. The menu offers exactly the commands the TUI answers, so nothing it
	103	+ suggests can come back as "unknown command".
	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.
83	108
84	109	`shift+tab` cycles between asking before every mutating call and accepting them
85	110	all, which is `-yolo` reached from the keyboard. The mode line says which is in

+22−2internal/agent/loop.goView File

@@ -6,6 +6,7 @@ import (
6	6	"errors"
7	7	"fmt"
8	8	"strings"
	9	+ "sync"
9	10
10	11	"harness/internal/llm"
11	12	"harness/internal/metrics"
@@ -126,6 +127,25 @@ type Agent struct {
126	127	// lastInputTokens is the size of the previous request as the API measured
127	128	// it, cached and uncached parts together.
128	129	lastInputTokens int
	130	+
	131	+ // mu guards the settings a front end can change while the loop is
	132	+ // running. Only effort is one today; the loop reads it once per request.
	133	+ mu sync.Mutex
	134	+ }
	135	+
	136	+ // SetEffort changes the effort level the turns that follow will ask for. An
	137	+ // empty level means the API's own default.
	138	+ func (a *Agent) SetEffort(level string) {
	139	+ a.mu.Lock()
	140	+ defer a.mu.Unlock()
	141	+ a.opts.Effort = level
	142	+ }
	143	+
	144	+ // Effort reports the level currently in force.
	145	+ func (a *Agent) Effort() string {
	146	+ a.mu.Lock()
	147	+ defer a.mu.Unlock()
	148	+ return a.opts.Effort
129	149	}
130	150
131	151	// New wires an agent. state and log may be freshly created by the caller so the
@@ -320,8 +340,8 @@ func (a *Agent) request() llm.Request {
320	340	Tools: defs,
321	341	Thinking: llm.Adaptive(),
322	342	}
323		- if a.opts.Effort != "" {
324		- req.OutputConfig = &llm.OutputConfig{Effort: a.opts.Effort}
	343	+ if effort := a.Effort(); effort != "" {
	344	+ req.OutputConfig = &llm.OutputConfig{Effort: effort}
325	345	}
326	346	return req
327	347	}

+26−0internal/agent/loop_test.goView File

@@ -527,3 +527,29 @@ func TestSystemPromptIsStableAcrossRequests(t *testing.T) {
527	527	t.Error("the system prompt changed between two requests in one session")
528	528	}
529	529	}
	530	+
	531	+ // Effort is a knob the TUI turns mid-session, so a request carries whatever
	532	+ // was last set rather than whatever the process started with.
	533	+ func TestSetEffortAppliesToTheNextRequest(t *testing.T) {
	534	+ f := newFakeAPI(t, msg("end_turn", textBlock("one")), msg("end_turn", textBlock("two")))
	535	+ a := newTestAgent(t, f, t.TempDir(), &bytes.Buffer{})
	536	+
	537	+ if _, err := a.Run(context.Background(), "first"); err != nil {
	538	+ t.Fatalf("Run: %v", err)
	539	+ }
	540	+ if oc := f.requests[0].OutputConfig; oc != nil {
	541	+ t.Errorf("output_config = %+v with no effort set, want it omitted so the API picks", oc)
	542	+ }
	543	+
	544	+ a.SetEffort("low")
	545	+ if got := a.Effort(); got != "low" {
	546	+ t.Errorf("Effort() = %q, want low", got)
	547	+ }
	548	+ if _, err := a.Run(context.Background(), "second"); err != nil {
	549	+ t.Fatalf("Run: %v", err)
	550	+ }
	551	+ oc := f.requests[1].OutputConfig
	552	+ if oc == nil \|\| oc.Effort != "low" {
	553	+ t.Errorf("output_config = %+v, want effort low", oc)
	554	+ }
	555	+ }

+15−0internal/llm/types.goView File

@@ -172,6 +172,21 @@ type OutputConfig struct {
172	172	Effort string `json:"effort,omitempty"`
173	173	}
174	174
	175	+ // EffortLevels are the values output_config.effort accepts, cheapest first.
	176	+ // Anything else is a 400 from the API, so callers check before sending.
	177	+ var EffortLevels = []string{"low", "medium", "high", "xhigh", "max"}
	178	+
	179	+ // ValidEffort reports whether level is one the API accepts. The empty string
	180	+ // is not: it means "say nothing", which callers handle by omitting the field.
	181	+ func ValidEffort(level string) bool {
	182	+ for _, l := range EffortLevels {
	183	+ if l == level {
	184	+ return true
	185	+ }
	186	+ }
	187	+ return false
	188	+ }
	189	+
175	190	// Request is the body of POST /v1/messages.
176	191	type Request struct {
177	192	Model string `json:"model"`

+15−0internal/llm/types_test.goView File

@@ -122,3 +122,18 @@ func TestResponseAccessors(t *testing.T) {
122	122	t.Errorf("Message() = %+v, want all 4 blocks under the assistant role", msg)
123	123	}
124	124	}
	125	+
	126	+ // The effort levels are a closed set, and both the -effort flag and the TUI's
	127	+ // /effort command answer out of it rather than keeping their own copy.
	128	+ func TestValidEffort(t *testing.T) {
	129	+ for _, level := range EffortLevels {
	130	+ if !ValidEffort(level) {
	131	+ t.Errorf("ValidEffort(%q) = false for a level we advertise", level)
	132	+ }
	133	+ }
	134	+ for _, level := range []string{"", "HIGH", "higher", "none"} {
	135	+ if ValidEffort(level) {
	136	+ t.Errorf("ValidEffort(%q) = true, want false", level)
	137	+ }
	138	+ }
	139	+ }

+84−0internal/tui/commands.goaddedView File

++ package tui
++ import (
++ 	"fmt"
++ 	"strings"
++ )
++ // command is one thing the prompt box accepts with a leading slash: either a
++ // control the TUI answers itself, or a skill the agent is asked to invoke.
++ type command struct {
++ 	name string // without the slash
++ 	args string // what may follow the name; "" when it takes none
++ 	desc string
++ 	tag  string // "personal" or "project" for a skill; "" for a built-in
++ }
++ // builtins are the commands submit answers without going near the model. The
++ // order is the order the menu offers them in — most reached-for first, not
++ // alphabetical, because the first row is the one a person lands on.
++ //
++ // This list is also what /help prints and what the completion menu offers, so
++ // none of the three can drift away from the others.
++ var builtins = []command{
++ 	{name: "help", desc: "the commands and the keys"},
++ 	{name: "skills", desc: "the instruction sets found at startup"},
++ 	{name: "effort", args: "level", desc: "how hard the model thinks: low … max"},
++ 	{name: "clear", desc: "empty the transcript"},
++ 	{name: "allowed", desc: "what is permanently allowed this session"},
++ 	{name: "exit", desc: "leave the harness"},
++ }
++ // commands is the catalogue: the built-ins, then every discovered skill.
++ func (m *model) commands() []command {
++ 	out := make([]command, 0, len(builtins)+len(m.opts.Skills))
++ 	out = append(out, builtins...)
++ 	for _, s := range m.opts.Skills {
++ 		desc := s.Description
++ 		if desc == "" {
++ 			desc = "a skill with no description"
++ 		}
++ 		out = append(out, command{name: s.Name, args: "arguments", desc: desc, tag: s.Source})
++ 	}
++ 	return out
++ }
++ // matchCommands narrows the catalogue to what has been typed after the slash.
++ // A name that starts with it comes before one that merely contains it, so
++ // "/sk" offers /skills before a skill called "ask-the-docs".
++ func matchCommands(all []command, typed string) []command {
++ 	if typed == "" {
++ 		return append([]command(nil), all...)
++ 	}
++ 	var prefix, contains []command
++ 	for _, c := range all {
++ 		switch {
++ 		case strings.HasPrefix(c.name, typed):
++ 			prefix = append(prefix, c)
++ 		case strings.Contains(c.name, typed):
++ 			contains = append(contains, c)
++ 		}
++ 	}
++ 	return append(prefix, contains...)
++ }
++ // helpText is built from the catalogue rather than written out beside it.
++ func (m *model) helpText() string {
++ 	var b strings.Builder
++ 	b.WriteString("commands:")
++ 	for _, c := range builtins {
++ 		name := "/" + c.name
++ 		if c.args != "" {
++ 			name += " <" + c.args + ">"
++ 		}
++ 		fmt.Fprintf(&b, "\n  %-18s %s", name, c.desc)
++ 	}
++ 	if n := len(m.opts.Skills); n > 0 {
++ 		fmt.Fprintf(&b, "\n  %-18s %s", "/<skill>", plural(n, "discovered skill")+" — /skills lists them")
++ 	}
++ 	b.WriteString("\nkeys: enter send · ctrl+j newline · shift+tab cycle approval mode" +
++ 		"\n      / opens the command menu · ↑↓ move · tab or enter complete · esc dismiss" +
++ 		"\n      ctrl+r toggle full tool output · pgup/pgdn scroll" +
++ 		"\n      esc or ctrl+c interrupt a turn · ctrl+c again to exit")
++ 	return b.String()
++ }

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

++ package tui
++ import (
++ 	"fmt"
++ 	"strings"
++ 	tea "github.com/charmbracelet/bubbletea"
++ 	"github.com/charmbracelet/lipgloss"
++ )
++ // menuMaxRows caps the completion list. Past about eight rows the menu is
++ // eating the transcript, and a list that long is faster to filter than to
++ // scroll anyway.
++ const menuMaxRows = 8
++ // menu is the slash-command completion list under the prompt. It is closed
++ // when it holds no items; there is no separate flag to disagree with that.
++ type menu struct {
++ 	items []command
++ 	idx   int
++ 	// dismissed is the prompt text the menu was last closed on. Accepting a
++ 	// completion leaves "/clear" in the box, which is exactly the text that
++ 	// would re-open the menu, so closing remembers what it closed on and
++ 	// stays shut until something else is typed.
++ 	dismissed string
++ }
++ func (m *model) menuOpen() bool { return len(m.menu.items) > 0 }
++ // menuQuery reports what has been typed after the slash, and whether a
++ // command is being typed at all. A slash anywhere but the start is prose; a
++ // space means the name is settled and what follows is its arguments.
++ func menuQuery(value string) (string, bool) {
++ 	if !strings.HasPrefix(value, "/") {
++ 		return "", false
++ 	}
++ 	rest := value[1:]
++ 	if strings.ContainsAny(rest, " \t\n") {
++ 		return "", false
++ 	}
++ 	return strings.ToLower(rest), true
++ }
++ // refreshMenu recomputes the list from what is in the prompt box. It runs
++ // after every keystroke the textarea sees, so the list follows the text
++ // rather than being opened and closed by particular keys.
++ func (m *model) refreshMenu() {
++ 	value := m.input.Value()
++ 	typed, typing := menuQuery(value)
++ 	if !typing || value == m.menu.dismissed || m.phase != phaseIdle {
++ 		m.menu.items, m.menu.idx = nil, 0
++ 		return
++ 	}
++ 	// Keep the highlight on the command it was on while the list narrows
++ 	// around it; otherwise start at the top.
++ 	var was string
++ 	if m.menuOpen() && m.menu.idx < len(m.menu.items) {
++ 		was = m.menu.items[m.menu.idx].name
++ 	}
++ 	m.menu.items, m.menu.idx = matchCommands(m.commands(), typed), 0
++ 	for i, c := range m.menu.items {
++ 		if c.name == was {
++ 			m.menu.idx = i
++ 		}
++ 	}
++ }
++ func (m *model) closeMenu() {
++ 	m.menu.items, m.menu.idx = nil, 0
++ 	m.menu.dismissed = m.input.Value()
++ }
++ // onMenuKey handles the keys that belong to an open menu, and reports whether
++ // it took the key. Everything it does not take falls through to the prompt,
++ // which is what keeps typing a filter rather than a command of its own.
++ func (m *model) onMenuKey(msg tea.KeyMsg) (tea.Cmd, bool) {
++ 	n := len(m.menu.items)
++ 	switch msg.String() {
++ 	case "up", "ctrl+p":
++ 		m.menu.idx = (m.menu.idx - 1 + n) % n
++ 		return nil, true
++ 	case "down", "ctrl+n":
++ 		m.menu.idx = (m.menu.idx + 1) % n
++ 		return nil, true
++ 	case "tab", "enter":
++ 		m.acceptCompletion()
++ 		return nil, true
++ 	case "esc":
++ 		m.closeMenu()
++ 		return nil, true
++ 	}
++ 	return nil, false
++ }
++ // acceptCompletion puts the highlighted command in the prompt box. It does
++ // not send it: a command that takes arguments is half-typed at this point, and
++ // one that does not is one more enter away.
++ func (m *model) acceptCompletion() {
++ 	c := m.menu.items[m.menu.idx]
++ 	text := "/" + c.name
++ 	if c.args != "" {
++ 		text += " "
++ 	}
++ 	m.input.SetValue(text)
++ 	m.input.CursorEnd()
++ 	m.closeMenu()
++ 	m.growInput()
++ }
++ // menuRows is how many lines the menu may take: what is left after the rest of
++ // the bottom chrome and one row of transcript, capped.
++ func (m *model) menuRows() int {
++ 	// activity line, the prompt box's three, the status line, the mode line,
++ 	// and a row of transcript to keep the menu from swallowing the screen.
++ 	room := m.height - 6 - m.input.Height()
++ 	return maxInt(1, minInt(menuMaxRows, room))
++ }
++ // menuView renders the list under the prompt: the highlighted row in coral
++ // with its description beside it, the rest dimmed.
++ func (m *model) menuView() string {
++ 	if !m.menuOpen() {
++ 		return ""
++ 	}
++ 	rows := m.menuRows()
++ 	shown := rows
++ 	if len(m.menu.items) > rows {
++ 		// The last row goes to the count of what did not fit.
++ 		shown = maxInt(1, rows-1)
++ 	}
++ 	start := 0
++ 	if m.menu.idx >= shown {
++ 		start = m.menu.idx - shown + 1
++ 	}
++ 	end := minInt(len(m.menu.items), start+shown)
++ 	// One column for the names, so the descriptions line up. A long skill
++ 	// name is left to overflow its column rather than being truncated: the
++ 	// name is the thing you are picking, and half of it is no use.
++ 	width := 0
++ 	for _, c := range m.menu.items[start:end] {
++ 		width = maxInt(width, lipgloss.Width("/"+c.name))
++ 	}
++ 	width = minInt(width, maxInt(12, m.width/3))
++ 	var b strings.Builder
++ 	for i := start; i < end; i++ {
++ 		c := m.menu.items[i]
++ 		name := pad("/"+c.name, width)
++ 		desc := c.desc
++ 		if c.tag != "" {
++ 			desc += " (" + c.tag + ")"
++ 		}
++ 		var line string
++ 		if i == m.menu.idx {
++ 			line = styKey.Render("❯ "+name) + " " + styText.Render(desc)
++ 		} else {
++ 			line = "  " + styDim.Render(name) + " " + styFaint.Render(desc)
++ 		}
++ 		b.WriteString(truncateStyled(" "+line, maxInt(1, m.width)) + "\n")
++ 	}
++ 	if n := len(m.menu.items) - (end - start); n > 0 {
++ 		b.WriteString(truncateStyled("   "+styFaint.Render(fmt.Sprintf("… +%d more", n)), maxInt(1, m.width)) + "\n")
++ 	}
++ 	return strings.TrimRight(b.String(), "\n")
++ }
++ // pad widens s to width cells, leaving anything already wider alone.
++ func pad(s string, width int) string {
++ 	if n := width - lipgloss.Width(s); n > 0 {
++ 		return s + strings.Repeat(" ", n)
++ 	}
++ 	return s
++ }

+222−0internal/tui/complete_test.goaddedView File

++ package tui
++ import (
++ 	"strings"
++ 	"testing"
++ 	tea "github.com/charmbracelet/bubbletea"
++ 	"harness/internal/skills"
++ )
++ // The menu belongs to a slash command being typed, and to nothing else: a
++ // message that merely mentions one must not open it.
++ func TestMenuQuery(t *testing.T) {
++ 	cases := []struct {
++ 		in       string
++ 		want     string
++ 		wantOpen bool
++ 	}{
++ 		{"/", "", true},
++ 		{"/ef", "ef", true},
++ 		{"/EF", "ef", true},
++ 		{"", "", false},
++ 		{"hello", "", false},
++ 		{"see /help for that", "", false},
++ 		{"/effort high", "", false}, // the name is settled; the menu is done
++ 		{"/help\nmore", "", false},  // a second line means a message, not a command
++ 		{" /help", "", false},
++ 	}
++ 	for _, tc := range cases {
++ 		got, open := menuQuery(tc.in)
++ 		if open != tc.wantOpen || got != tc.want {
++ 			t.Errorf("menuQuery(%q) = %q, %v; want %q, %v", tc.in, got, open, tc.want, tc.wantOpen)
++ 		}
++ 	}
++ }
++ func names(cmds []command) []string {
++ 	var out []string
++ 	for _, c := range cmds {
++ 		out = append(out, c.name)
++ 	}
++ 	return out
++ }
++ // Typing narrows the list, and a name that starts with what was typed beats
++ // one that merely contains it.
++ func TestMatchCommandsRanksPrefixesFirst(t *testing.T) {
++ 	all := []command{
++ 		{name: "allowed"},
++ 		{name: "clear"},
++ 		{name: "effort"},
++ 		{name: "reformat-everything"},
++ 	}
++ 	cases := map[string][]string{
++ 		"":       {"allowed", "clear", "effort", "reformat-everything"},
++ 		"e":      {"effort", "allowed", "clear", "reformat-everything"},
++ 		"ef":     {"effort", "reformat-everything"},
++ 		"format": {"reformat-everything"},
++ 		"zz":     nil,
++ 	}
++ 	for typed, want := range cases {
++ 		got := names(matchCommands(all, typed))
++ 		if strings.Join(got, ",") != strings.Join(want, ",") {
++ 			t.Errorf("matchCommands(%q) = %v, want %v", typed, got, want)
++ 		}
++ 	}
++ }
++ // The catalogue is the union of what the TUI answers itself and what the
++ // session discovered, so a skill is reachable from the menu by name.
++ func TestCommandsListBuiltinsAndSkills(t *testing.T) {
++ 	m := newTestModel(t)
++ 	m.opts.Skills = []skills.Skill{
++ 		{Name: "brainstorming", Description: "explore an idea", Source: "personal"},
++ 	}
++ 	got := names(m.commands())
++ 	for _, want := range []string{"help", "effort", "skills", "exit", "brainstorming"} {
++ 		if !strings.Contains(strings.Join(got, ","), want) {
++ 			t.Errorf("command %q missing from the catalogue %v", want, got)
++ 		}
++ 	}
++ 	for _, c := range m.commands() {
++ 		if c.desc == "" {
++ 			t.Errorf("command /%s has no description to show in the menu", c.name)
++ 		}
++ 	}
++ }
++ // Every name the menu offers must be one submit actually answers; otherwise
++ // the menu is advertising commands that report themselves as unknown.
++ func TestEveryOfferedCommandIsHandled(t *testing.T) {
++ 	catalogue := newTestModel(t).commands()
++ 	for _, c := range catalogue {
++ 		m := newTestModel(t)
++ 		m.opts.Skills = []skills.Skill{{Name: "brainstorming", Description: "explore an idea"}}
++ 		m.submit("/" + c.name)
++ 		if out := m.tr.render(); strings.Contains(out, "unknown command") {
++ 			t.Errorf("/%s is offered by the menu but not handled: %q", c.name, out)
++ 		}
++ 	}
++ }
++ // Moving and accepting: the highlighted name lands in the prompt box, and
++ // accepting is not sending — the turn starts on the next enter.
++ func TestMenuCompletesWithoutSending(t *testing.T) {
++ 	m := newTestModel(t)
++ 	typeIn(m, "/")
++ 	if !m.menuOpen() {
++ 		t.Fatal("typing a slash did not open the menu")
++ 	}
++ 	first := m.menu.items[0].name
++ 	m.Update(key("down"))
++ 	second := m.menu.items[m.menu.idx].name
++ 	if second == first {
++ 		t.Fatal("down did not move the highlight")
++ 	}
++ 	m.Update(key("enter"))
++ 	if m.menuOpen() {
++ 		t.Error("the menu stayed open after accepting")
++ 	}
++ 	if got := m.input.Value(); !strings.HasPrefix(got, "/"+second) {
++ 		t.Errorf("input = %q, want it completed to /%s", got, second)
++ 	}
++ 	if m.phase != phaseIdle {
++ 		t.Error("accepting a completion started a turn; it should only fill the box")
++ 	}
++ }
++ // A command that takes arguments is completed with the space already typed;
++ // one that does not is completed bare and the menu does not re-open on it.
++ func TestCompletionTrailingSpaceFollowsArguments(t *testing.T) {
++ 	m := newTestModel(t)
++ 	m.opts.Skills = []skills.Skill{{Name: "brainstorming", Description: "explore an idea"}}
++ 	typeIn(m, "/brainstorm")
++ 	m.Update(key("tab"))
++ 	if got := m.input.Value(); got != "/brainstorming " {
++ 		t.Errorf("input = %q, want a trailing space for a command that takes arguments", got)
++ 	}
++ 	m2 := newTestModel(t)
++ 	typeIn(m2, "/clear")
++ 	m2.Update(key("tab"))
++ 	if got := m2.input.Value(); got != "/clear" {
++ 		t.Errorf("input = %q, want no trailing space on an argument-free command", got)
++ 	}
++ 	if m2.menuOpen() {
++ 		t.Error("the menu re-opened on the text it had just completed")
++ 	}
++ }
++ // Escape is for dismissing the menu, and only that: the text survives.
++ func TestEscapeClosesMenuKeepingText(t *testing.T) {
++ 	m := newTestModel(t)
++ 	typeIn(m, "/help")
++ 	if !m.menuOpen() {
++ 		t.Fatal("menu not open")
++ 	}
++ 	m.Update(key("esc"))
++ 	if m.menuOpen() {
++ 		t.Error("escape did not close the menu")
++ 	}
++ 	if got := m.input.Value(); got != "/help" {
++ 		t.Errorf("input = %q, want the typed text left alone", got)
++ 	}
++ 	// With the menu gone, enter sends what was typed.
++ 	m.Update(key("enter"))
++ 	if !strings.Contains(m.tr.render(), "commands:") {
++ 		t.Error("enter after dismissing the menu did not run the command")
++ 	}
++ }
++ // Typing past the last match closes the menu rather than showing an empty box.
++ func TestMenuClosesWhenNothingMatches(t *testing.T) {
++ 	m := newTestModel(t)
++ 	typeIn(m, "/zzzq")
++ 	if m.menuOpen() {
++ 		t.Errorf("menu open with no matches: %v", names(m.menu.items))
++ 	}
++ }
++ // The menu sits in the bottom chrome, which must still leave the transcript
++ // somewhere to live on a short terminal.
++ func TestMenuFitsTheTerminal(t *testing.T) {
++ 	for _, h := range []int{10, 24, 60} {
++ 		m := newTestModel(t)
++ 		m.Update(tea.WindowSizeMsg{Width: 80, Height: h})
++ 		typeIn(m, "/")
++ 		if !m.menuOpen() {
++ 			t.Fatalf("height %d: menu did not open", h)
++ 		}
++ 		view := m.View()
++ 		if got := strings.Count(view, "\n") + 1; got > h {
++ 			t.Errorf("height %d: view is %d lines, one row of the menu too many", h, got)
++ 		}
++ 		if !strings.Contains(view, "/help") {
++ 			t.Errorf("height %d: the menu rendered nothing", h)
++ 		}
++ 	}
++ }
++ // While the agent has the turn, enter is refused and esc means interrupt, so
++ // a menu opened under it would offer keys that do not do what it says.
++ func TestMenuStaysShutWhileTheAgentWorks(t *testing.T) {
++ 	m := newTestModel(t)
++ 	m.phase = phaseRunning
++ 	typeIn(m, "/he")
++ 	if m.menuOpen() {
++ 		t.Error("the menu opened during a turn")
++ 	}
++ 	m.Update(key("esc"))
++ 	if !m.interrupting {
++ 		t.Error("esc was eaten by the menu instead of interrupting the turn")
++ 	}
++ }

+56−6internal/tui/model.goView File

@@ -88,6 +88,9 @@ type model struct {
88	88	// open with the same word.
89	89	verbSeed int
90	90
	91	+ // menu is the slash-command completion list under the prompt.
	92	+ menu menu
	93	+
91	94	// pending approvals. The agent blocks on one at a time, but a queue costs
92	95	// nothing and means a second request can never be dropped.
93	96	pending []approvalMsg
@@ -331,6 +334,14 @@ func (m *model) onKey(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
331	334	return m.onApprovalKey(msg)
332	335	}
333	336
	337	+ // An open menu owns the keys that drive it — including enter and esc,
	338	+ // which mean something else the rest of the time.
	339	+ if m.menuOpen() {
	340	+ if cmd, took := m.onMenuKey(msg); took {
	341	+ return m, cmd
	342	+ }
	343	+ }
	344	+
334	345	switch msg.String() {
335	346	case "ctrl+c":
336	347	// While a turn runs, ctrl-c interrupts it and leaves the session
@@ -378,12 +389,14 @@ func (m *model) onKey(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
378	389	}
379	390	m.input.Reset()
380	391	m.growInput()
	392	+ m.closeMenu()
381	393	return m.submit(line)
382	394	}
383	395
384	396	var cmd tea.Cmd
385	397	m.input, cmd = m.input.Update(msg)
386	398	m.growInput()
	399	+ m.refreshMenu()
387	400	return m, cmd
388	401	}
389	402
@@ -433,9 +446,12 @@ func (m *model) submit(line string) (tea.Model, tea.Cmd) {
433	446	return m, tea.Quit
434	447
435	448	case line == "/help":
436		- m.tr.addNotice(helpText)
	449	+ m.tr.addNotice(m.helpText())
437	450	return m, m.sync()
438	451
	452	+ case line == "/effort" \|\| strings.HasPrefix(line, "/effort "):
	453	+ return m, m.setEffort(strings.TrimSpace(strings.TrimPrefix(line, "/effort")))
	454	+
439	455	case line == "/clear":
440	456	m.tr.clear()
441	457	return m, m.sync()
@@ -475,6 +491,42 @@ func (m *model) submit(line string) (tea.Model, tea.Cmd) {
475	491	return m, tea.Batch(m.sync(), m.spin.Tick, m.runTurn(line))
476	492	}
477	493
	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.
	496	+ func (m *model) setEffort(level string) tea.Cmd {
	497	+ switch {
	498	+ case level == "":
	499	+ m.tr.addNotice("effort: " + effortListing(m.opts.Effort))
	500	+ case !llm.ValidEffort(level):
	501	+ m.tr.addError("unknown effort " + level + " — one of " + strings.Join(llm.EffortLevels, ", "))
	502	+ 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")
	508	+ }
	509	+ return m.sync()
	510	+ }
	511	+
	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	+
478	530	// isSkill reports whether a slash command names a discovered skill. Matching
479	531	// here rather than sending every unrecognised slash to the model means a typo
480	532	// is caught by the harness instead of puzzled over by the agent.
@@ -576,11 +628,6 @@ func matches(keys []string, key string) bool {
576	628
577	629	// ---- view ---------------------------------------------------------------
578	630
579		- const helpText = `commands: /allowed /clear /help /skills /exit
580		- keys: enter send · ctrl+j newline · shift+tab cycle approval mode
581		- ctrl+r toggle full tool output · pgup/pgdn scroll
582		- esc or ctrl+c interrupt a turn · ctrl+c again to exit`
583		-
584	631	func (m *model) View() string {
585	632	if !m.ready {
586	633	return "starting…"
@@ -610,6 +657,9 @@ func (m *model) bottom() string {
610	657	b.WriteString(m.approvalView() + "\n")
611	658	} else {
612	659	b.WriteString(m.inputBox() + "\n")
	660	+ if v := m.menuView(); v != "" {
	661	+ b.WriteString(v + "\n")
	662	+ }
613	663	}
614	664	b.WriteString(m.status() + "\n")
615	665	b.WriteString(m.modeLine())

+67−0internal/tui/model_test.goView File

@@ -37,10 +37,24 @@ func key(s string) tea.KeyMsg {
37	37	return tea.KeyMsg{Type: tea.KeyCtrlR}
38	38	case "shift+tab":
39	39	return tea.KeyMsg{Type: tea.KeyShiftTab}
	40	+ case "tab":
	41	+ return tea.KeyMsg{Type: tea.KeyTab}
	42	+ case "up":
	43	+ return tea.KeyMsg{Type: tea.KeyUp}
	44	+ case "down":
	45	+ return tea.KeyMsg{Type: tea.KeyDown}
40	46	}
41	47	return tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune(s)}
42	48	}
43	49
	50	+ // typeIn sends a string one keystroke at a time, the way a person produces
	51	+ // it: the completion menu reacts to keys, not to the value being assigned.
	52	+ func typeIn(m *model, s string) {
	53	+ for _, r := range s {
	54	+ m.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{r}})
	55	+ }
	56	+ }
	57	+
44	58	// pend queues an approval the way the bridge would, and returns the channel
45	59	// the model is expected to answer on.
46	60	func pend(m *model, req approval.Request) chan approval.Decision {
@@ -417,3 +431,56 @@ func TestViewShowsApprovalOptionsConditionally(t *testing.T) {
417	431	t.Error("opaque command offered an option that would be a lie")
418	432	}
419	433	}
	434	+
	435	+ // /effort is the one command that changes how the next turn runs, so it has to
	436	+ // take, be visible in the chrome, and reach the agent.
	437	+ func TestEffortCommandSetsTheLevel(t *testing.T) {
	438	+ m := newTestModel(t)
	439	+ m.submit("/effort xhigh")
	440	+
	441	+ if m.opts.Effort != "xhigh" {
	442	+ t.Errorf("effort = %q, want xhigh", m.opts.Effort)
	443	+ }
	444	+ if !strings.Contains(m.activity(), "xhigh") {
	445	+ t.Errorf("the effort pill still reads %q", m.activity())
	446	+ }
	447	+ if !strings.Contains(m.tr.render(), "xhigh") {
	448	+ t.Error("the change was not reported in the transcript")
	449	+ }
	450	+ }
	451	+
	452	+ func TestEffortCommandRejectsAnUnknownLevel(t *testing.T) {
	453	+ m := newTestModel(t)
	454	+ m.opts.Effort = "high"
	455	+ m.submit("/effort ludicrous")
	456	+
	457	+ if m.opts.Effort != "high" {
	458	+ t.Errorf("effort = %q, want the previous level kept", m.opts.Effort)
	459	+ }
	460	+ out := m.tr.render()
	461	+ if !strings.Contains(out, "ludicrous") \|\| !strings.Contains(out, "xhigh") {
	462	+ t.Errorf("want the bad level named and the good ones listed, got %q", out)
	463	+ }
	464	+ if m.phase != phaseIdle {
	465	+ t.Error("a rejected effort still started a turn")
	466	+ }
	467	+ }
	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	+ }