johannSoCodeyPublic

tui: /settings, and a config that knows when setup is done

The config file has held the defaults since the wizard was built, but
the only way to change one of them was to sit through the whole
interview again — four questions to move the theme one row. And "first
run" was spelled as "no file exists", which is not the same statement:
a config written by hand, or by a build with fewer questions in it, is a
file, and nobody had ever been asked anything.

So the file now says so itself. The wizard stamps "setup": "done" when
the last question is answered, and that marker, not the file's
existence, is what suppresses the wizard on startup. Anything else in
that field is dropped on read, because a marker this build did not write
is not one it can trust. A config that cannot be parsed still suppresses
it, as before: the wizard's answers would be saved over settings that
are probably still in there.

/settings is the same four settings without the interview. One row
each, ←→ cycles a row, and the change is applied to the running session
as you move — the theme repaints under the panel, the effort pill above
the prompt changes — so there is nothing left to confirm on the way out
and esc only decides about the file. A panel that was only read leaves
it alone, and so does a value cycled back to where it started.

Only the rows actually touched are written back. The panel shows the
session rather than the file, because /effort, shift+tab and -yolo all
change a setting without the file hearing about it and a panel that
disagreed with the status bar two lines below it would be worse than
useless — but reading all four back off the session would write "accept
everything" into the config of someone who passed -yolo once, on the
command line, for one run.

The panel does not stamp the setup marker. It means the questions were
all asked and answered, and this screen does not ask them: someone who
has only ever changed their theme has not been through setup and is
still offered it.

The model row is the one that cannot cycle, because its choices come
from the endpoint rather than from this build, so enter hands over to
the /model picker and the picker lands back on the panel. Every other
row is built from the same option lists the wizard's steps are made of,
so the two screens cannot come to disagree about what a theme is called
or what an effort level means.

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

Browse Files

Jjonicommitted 4 weeks ago1 parent 00e7e95commitc23aec0

Showing 12 changed files with 951 additions and 22 deletions.

+47−7README.mdView File

@@ -137,7 +137,7 @@ 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		- `/mouse`, `/setup`, `/skills`, and one per discovered skill.
	140	+ `/mouse`, `/settings`, `/setup`, `/skills`, and one per discovered skill.
141	141
142	142	### The mouse
143	143
@@ -270,8 +270,8 @@ force shows above the prompt on the right. A terminal too narrow for five
270	270	labels gets `◀ high ▶` and the same keys rather than a track with the words
271	271	sliced in half.
272	272
273		- `/model` and `/effort` change the session. `/setup` changes what the next
274		- session starts with — see [Setup](#setup).
	273	+ `/model` and `/effort` change the session. `/settings` and `/setup` change what
	274	+ the next session starts with — see [Setup](#setup).
275	275
276	276	`shift+tab` cycles between asking before every mutating call and accepting them
277	277	all, which is `-yolo` reached from the keyboard. The mode line says which is in
@@ -293,6 +293,10 @@ cannot.
293	293
294	294	The first run on a terminal opens a full-screen wizard instead of the chat: the
295	295	mark assembles, the name lights up, and it asks four questions one at a time.
	296	+ "First run" means the config file does not say `"setup": "done"` — the marker
	297	+ the wizard stamps when the last question is answered — rather than that no file
	298	+ exists, so a config written by hand, or by a build with fewer questions in it,
	299	+ still gets asked the ones it is missing.
296	300
297	301	```
298	302	harness setup step 1 of 4
@@ -338,7 +342,8 @@ honoured):
338	342	"model": "claude-opus-5",
339	343	"effort": "high",
340	344	"approvals": "ask",
341		- "theme": "ember"
	345	+ "theme": "ember",
	346	+ "setup": "done"
342	347	}
343	348	```
344	349
@@ -360,9 +365,44 @@ model than it started. A config file that cannot be parsed is reported and then
360	365	ignored, and is never overwritten until you finish the wizard.
361	366
362	367	`/model` and `/effort` change the running session and say "from the next turn
363		- on"; they do not write to the file. The wizard is the thing that decides what
364		- the next session starts with, which is why it is a separate screen rather
365		- than a fourth picker.
	368	+ on"; they do not write to the file. The two screens that do are the wizard and
	369	+ `/settings`.
	370	+
	371	+ ### /settings
	372	+
	373	+ `/settings` is the same four settings without the interview: one row each,
	374	+ changed in place, applied as you move.
	375	+
	376	+ ```
	377	+ Settings ↑↓ row · ←→ change · esc done
	378	+ ❯ Model Opus 5 $5 / $25 per Mtok
	379	+ Effort high default
	380	+ Approvals Ask me first recommended
	381	+ Theme ember
	382	+ claude-opus-5 · enter to pick from anthropic
	383	+ saved to ~/.config/harness/config.json
	384	+ ```
	385	+
	386	+ `←→` cycles a row and applies it there and then — the theme repaints under the
	387	+ panel, the way it previews in the wizard — and `esc` closes and writes the
	388	+ file. There is no cancel, because there is nothing left to confirm: the session
	389	+ already has every change. A panel that was only read leaves the file alone, and
	390	+ so does a value cycled back to where it started.
	391	+
	392	+ The rows come from the same option lists the wizard's steps are built from, so
	393	+ neither screen can invent a name for a theme or a sentence about an effort
	394	+ level the other does not use. The model row is the exception: its choices come
	395	+ from the endpoint rather than from this build, so `enter` hands over to the
	396	+ `/model` picker and lands back here once you have chosen.
	397	+
	398	+ What the panel shows is the session, not the file — `/effort`, `shift+tab`
	399	+ and `-yolo` all change a setting without the file hearing about it, and a panel
	400	+ that disagreed with the status bar two lines below it would be worse than
	401	+ useless. Only the rows actually touched are written back, which is what keeps a
	402	+ `-yolo` run from quietly saving "accept everything" as the default for every
	403	+ run after it. And the setup marker is not stamped here: changing a theme is
	404	+ not answering the setup questions, so someone who has only ever used this panel
	405	+ is still offered the wizard.
366	406
367	407	The whole thing is `↑↓` and `enter`, `esc` to go back. Animations collapse to
368	408	their final frame under `NO_COLOR`, a `dumb` terminal, or a window under 60×20,

+9−6cmd/harness/main.goView File

@@ -68,7 +68,7 @@ func run() error {
68	68	// Saved preferences sit under the flags and over the built-in defaults. A
69	69	// config that cannot be read is reported and then ignored: the harness
70	70	// still starts, and the wizard can write a good one over it.
71		- cfg, haveConfig, cfgErr := config.Load()
	71	+ cfg, _, cfgErr := config.Load()
72	72
73	73	// Held as a slice because the Claude Code fallback below may have to
74	74	// rebuild the client with one more option, and replaying the same list is
@@ -265,12 +265,15 @@ func run() error {
265	265
266	266	Banner: banner,
267	267
268		- // No config on disk is what "first run" means, and it is the only
269		- // thing that opens the wizard unasked. A flag-only invocation is
270		- // still a first run: the flags say what this run does, not what
271		- // the next one should default to.
	268	+ // A config that does not say the setup was finished is what
	269	+ // "first run" means, and it is the only thing that opens the
	270	+ // wizard unasked. A flag-only invocation is still a first run:
	271	+ // the flags say what this run does, not what the next one should
	272	+ // default to. A config we could not read is not a first run
	273	+ // either — the wizard's answers would be saved over settings that
	274	+ // are probably still in there.
272	275	Config: cfg,
273		- FirstRun: !haveConfig && cfgErr == nil,
	276	+ FirstRun: !cfg.Done() && cfgErr == nil,
274	277	// Applying the answers is the TUI's own job; persisting them is
275	278	// the only part that belongs out here.
276	279	SaveConfig: config.Save,

+22−0internal/config/config.goView File

@@ -32,6 +32,11 @@ const (
32	32	ApprovalsAcceptAll = "accept-all"
33	33	)
34	34
	35	+ // SetupDone is what the Setup field says once the wizard has been all the way
	36	+ // through. It is a word rather than a bool for the same reason the approval
	37	+ // modes are: a file that reads "setup": false looks like something failed.
	38	+ const SetupDone = "done"
	39	+
35	40	// Themes are the TUI palettes, in the order the wizard offers them. The names
36	41	// live here rather than in the tui package so that reading a config never
37	42	// depends on a terminal front end being linked in — the eval runner has none.
@@ -51,8 +56,20 @@ type Config struct {
51	56	Approvals string `json:"approvals,omitempty"`
52	57	// Theme is one of Themes.
53	58	Theme string `json:"theme,omitempty"`
	59	+ // Setup is SetupDone once the questions have been answered to the end.
	60	+ //
	61	+ // It is what decides whether the wizard opens by itself, in place of the
	62	+ // older test of whether the file exists at all. The difference shows up on
	63	+ // a config that exists but was never finished — written by hand, or by a
	64	+ // build that had fewer questions in it — where "the file is there" would
	65	+ // say the setup was done and this says who says so.
	66	+ Setup string `json:"setup,omitempty"`
54	67	}
55	68
	69	+ // Done reports whether the setup has been completed. It is the only thing
	70	+ // that suppresses the wizard on startup.
	71	+ func (c Config) Done() bool { return c.Setup == SetupDone }
	72	+
56	73	// Path is where the config lives: $XDG_CONFIG_HOME/harness/config.json, or
57	74	// ~/.config/harness/config.json when XDG_CONFIG_HOME is unset.
58	75	func Path() (string, error) {
@@ -107,6 +124,11 @@ func sanitize(c Config) Config {
107	124	if !ValidTheme(c.Theme) {
108	125	c.Theme = ""
109	126	}
	127	+ // Anything other than the one word means the marker was not written by a
	128	+ // wizard that finished, so it does not count as one.
	129	+ if c.Setup != SetupDone {
	130	+ c.Setup = ""
	131	+ }
110	132	return c
111	133	}
112	134

+50−0internal/config/config_test.goView File

   		t.Errorf("two empties produced %q", got)
+  	}
+  }
++ // The marker is what suppresses the wizard, so it has to survive the file
++ // unchanged — and a config without it has to keep reading as unfinished.
++ func TestSetupMarkerRoundTrips(t *testing.T) {
++ 	isolate(t)
++ 	if (Config{Model: "claude-opus-5"}).Done() {
++ 		t.Error("a config with no marker reported the setup as done")
++ 	}
++ 	want := Config{Model: "claude-opus-5", Theme: "mono", Setup: SetupDone}
++ 	if err := Save(want); err != nil {
++ 		t.Fatal(err)
++ 	}
++ 	got, found, err := Load()
++ 	if err != nil || !found {
++ 		t.Fatalf("Load(found=%v): %v", found, err)
++ 	}
++ 	if !got.Done() {
++ 		t.Errorf("the setup marker did not survive the round trip: %+v", got)
++ 	}
++ }
++ // A config that exists but was never finished is the case the marker exists
++ // for: the file is there, and the wizard still has questions to ask.
++ func TestAnUnfinishedConfigIsNotDone(t *testing.T) {
++ 	path := isolate(t)
++ 	if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
++ 		t.Fatal(err)
++ 	}
++ 	// A marker of the wrong type — "setup": true, the obvious wrong guess for
++ 	// someone editing by hand — is not in this list: that is a parse failure
++ 	// for the whole file, which Load already reports rather than papering over.
++ 	for _, body := range []string{
++ 		`{"version":1,"theme":"mint"}`,
++ 		`{"version":1,"theme":"mint","setup":"maybe"}`,
++ 		`{"version":1,"theme":"mint","setup":""}`,
++ 	} {
++ 		if err := os.WriteFile(path, []byte(body), 0o644); err != nil {
++ 			t.Fatal(err)
++ 		}
++ 		cfg, _, _ := Load()
++ 		if cfg.Done() {
++ 			t.Errorf("%s reported the setup as done", body)
++ 		}
++ 		if cfg.Theme != "mint" {
++ 			t.Errorf("%s lost the settings it did have: %+v", body, cfg)
++ 		}
++ 	}
++ }

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

@@ -25,6 +25,7 @@ var builtins = []command{
25	25	{name: "skills", desc: "the instruction sets found at startup"},
26	26	{name: "model", args: "id", desc: "switch model — lists what the endpoint serves"},
27	27	{name: "effort", args: "level", desc: "how hard the model thinks — opens a slider"},
	28	+ {name: "settings", desc: "change the saved defaults, a row at a time"},
28	29	{name: "setup", desc: "the full-screen wizard for the saved defaults"},
29	30	{name: "clear", desc: "empty the transcript"},
30	31	{name: "mouse", desc: "hand the mouse back to the terminal, or take it again"},

+20−0internal/tui/model.goView File

@@ -70,6 +70,9 @@ const (
70	70	// phaseModel is the model picker, which starts on a wait: the list comes
71	71	// from the endpoint.
72	72	phaseModel
	73	+ // phaseSettings is the settings panel, where the saved defaults are
	74	+ // changed in place.
	75	+ phaseSettings
73	76	)
74	77
75	78	// inputMaxLines caps how far the prompt box grows before it scrolls. Past
@@ -127,6 +130,17 @@ type model struct {
127	130	// effortIdx is where the marker sits while the effort slider is up.
128	131	effortIdx int
129	132
	133	+ // The settings panel. setIdx is the row under the cursor and setTouched
	134	+ // is which rows were actually changed, which is what gets written back —
	135	+ // see settingsConfig. setFrom records that the model picker was opened
	136	+ // from the panel, so it knows to return there, and setModelWas is the
	137	+ // model the panel opened on, which is how a trip through the picker is
	138	+ // noticed without the two having to agree on an order.
	139	+ setIdx settingRow
	140	+ setTouched [numSettingRows]bool
	141	+ setFrom bool
	142	+ setModelWas string
	143	+
130	144	// The model picker: what the endpoint offered, where the cursor is, and
131	145	// whether we are still waiting to be told.
132	146	models []llm.Model
@@ -524,6 +538,9 @@ func (m *model) onKey(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
524	538	if m.phase == phaseModel {
525	539	return m.onModelKey(msg)
526	540	}
	541	+ if m.phase == phaseSettings {
	542	+ return m.onSettingsKey(msg)
	543	+ }
527	544
528	545	// An open menu owns the keys that drive it — including enter and esc,
529	546	// which mean something else the rest of the time.
@@ -688,6 +705,9 @@ func (m *model) submit(line string) (tea.Model, tea.Cmd) {
688	705	}
689	706	return m, m.sync()
690	707
	708	+ case line == "/settings":
	709	+ return m, m.openSettings()
	710	+
691	711	case line == "/setup":
692	712	if m.phase == phaseRunning {
693	713	m.tr.addError("/setup would change the model mid-turn — interrupt first")

+4−4internal/tui/model_picker.goView File

@@ -51,16 +51,16 @@ func (m *model) onModels(msg modelsMsg) tea.Cmd {
51	51	return nil
52	52	}
53	53	m.modelsLoading = false
54		- m.phase = phaseIdle
55	54
56	55	switch {
57	56	case msg.err != nil:
	57	+ m.phase = m.backFromPicker()
58	58	m.tr.addError("could not list models from " + endpointLabel(m.opts.Client) + ": " +
59	59	msg.err.Error() + " — this endpoint may not serve /v1/models; -model or /model <id> still works")
60	60	case len(msg.models) == 0:
	61	+ m.phase = m.backFromPicker()
61	62	m.tr.addError(endpointLabel(m.opts.Client) + " returned no models — -model or /model <id> still works")
62	63	default:
63		- m.phase = phaseModel
64	64	m.models = msg.models
65	65	m.modelIdx = modelIndex(msg.models, m.opts.Client.Model())
66	66	}
@@ -83,7 +83,7 @@ func modelIndex(models []llm.Model, current string) int {
83	83	func (m *model) onModelKey(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
84	84	key := msg.String()
85	85	if key == "esc" \|\| key == "ctrl+c" {
86		- m.phase = phaseIdle
	86	+ m.phase = m.backFromPicker()
87	87	m.models, m.modelsLoading = nil, false
88	88	return m, tea.Batch(m.sync(), textarea.Blink)
89	89	}
@@ -103,7 +103,7 @@ func (m *model) onModelKey(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
103	103	m.modelIdx = last
104	104	case "enter", "tab":
105	105	id := m.models[m.modelIdx].ID
106		- m.phase = phaseIdle
	106	+ m.phase = m.backFromPicker()
107	107	m.models = nil
108	108	m.applyModel(id)
109	109	return m, tea.Batch(m.sync(), textarea.Blink)

+25−1internal/tui/mouse.goView File

@@ -36,6 +36,7 @@ const (
36	36	secApproval
37	37	secEffort
38	38	secModel
	39	+ secSettings
39	40	)
40	41
41	42	// section is one piece of the bottom chrome and what it rendered to. The
@@ -58,6 +59,8 @@ func (m *model) layout() []section {
58	59	secs = append(secs, section{secEffort, m.effortView()})
59	60	case m.phase == phaseModel:
60	61	secs = append(secs, section{secModel, m.modelView()})
	62	+ case m.phase == phaseSettings:
	63	+ secs = append(secs, section{secSettings, m.settingsView()})
61	64	default:
62	65	secs = append(secs, section{secInput, m.inputBox()})
63	66	if v := m.menuView(); v != "" {
@@ -255,6 +258,12 @@ func (m *model) onChromeWheel(kind sectionKind, msg tea.MouseMsg) tea.Cmd {
255	258	case secEffort:
256	259	m.effortIdx = clampIdx(m.effortIdx+step(up), len(llm.EffortLevels))
257	260	return nil
	261	+ case secSettings:
	262	+ // The wheel moves between rows rather than changing a value: a roll
	263	+ // that silently turned approvals off would be the worst possible
	264	+ // thing for it to do.
	265	+ m.setIdx = settingRow(clampIdx(int(m.setIdx)+step(up), int(numSettingRows)))
	266	+ return nil
258	267	}
259	268	var cmd tea.Cmd
260	269	m.vp, cmd = m.vp.Update(msg)
@@ -284,7 +293,7 @@ func (m *model) onChromeClick(kind sectionKind, row, x int) (tea.Model, tea.Cmd)
284	293	if i := start + row - modelHeadRows; row >= modelHeadRows && i < end {
285	294	m.modelIdx = i
286	295	id := m.models[i].ID
287		- m.phase, m.models = phaseIdle, nil
	296	+ m.phase, m.models = m.backFromPicker(), nil
288	297	m.applyModel(id)
289	298	return m, tea.Batch(m.sync(), textarea.Blink)
290	299	}
@@ -312,6 +321,21 @@ func (m *model) onChromeClick(kind sectionKind, row, x int) (tea.Model, tea.Cmd)
312	321	}
313	322	return m, nil
314	323
	324	+ case secSettings:
	325	+ // A click on a row is a choice, like everywhere else in the chrome:
	326	+ // it moves the cursor there and does what enter would have done.
	327	+ i := row - settingsHeadRows
	328	+ if i < 0 \|\| i >= int(numSettingRows) {
	329	+ return m, nil
	330	+ }
	331	+ m.setIdx = settingRow(i)
	332	+ if m.setIdx == setModelRow {
	333	+ m.setFrom = true
	334	+ return m, m.openModelPicker()
	335	+ }
	336	+ m.cycleSetting(m.setIdx, 1)
	337	+ return m, m.sync()
	338	+
315	339	case secMode:
316	340	return m, m.cycleMode()
317	341	}

+375−0internal/tui/settings.goaddedView File

++ package tui
++ import (
++ 	"strings"
++ 	"github.com/charmbracelet/bubbles/textarea"
++ 	tea "github.com/charmbracelet/bubbletea"
++ 	"github.com/charmbracelet/lipgloss"
++ 	"harness/internal/config"
++ )
++ // The settings panel: /settings. One row per thing the config file holds,
++ // changed in place and applied as you move, which is what separates it from
++ // the setup wizard. The wizard is an interview — it asks every question once,
++ // in order, and is how the file comes to exist. This is the amendment: open
++ // it, change the one thing, leave.
++ //
++ // Everything it offers comes from the same option lists the wizard's steps are
++ // built from, so the two screens cannot come to disagree about what a theme is
++ // called or what an effort level means.
++ type settingRow int
++ const (
++ 	setModelRow settingRow = iota
++ 	setEffortRow
++ 	setApprovalsRow
++ 	setThemeRow
++ 	numSettingRows
++ )
++ var settingLabels = [numSettingRows]string{"Model", "Effort", "Approvals", "Theme"}
++ // settingsHeadRows is how many rows sit above the list: the heading, which
++ // carries the keys on its right.
++ const settingsHeadRows = 1
++ // openSettings puts the panel up, on the row most likely to be wanted.
++ func (m *model) openSettings() tea.Cmd {
++ 	m.phase = phaseSettings
++ 	m.setIdx = setModelRow
++ 	m.setTouched = [numSettingRows]bool{}
++ 	m.setModelWas = m.modelInForce()
++ 	// A theme change repaints everything, including whatever was marked.
++ 	m.clearSelection()
++ 	m.closeMenu()
++ 	return m.sync()
++ }
++ // onSettingsKey drives the panel. Like the other full-width pieces of chrome
++ // it answers every key while it is up: there is no prompt behind it to type
++ // into, so nothing falls through.
++ func (m *model) onSettingsKey(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
++ 	switch key := msg.String(); key {
++ 	case "esc", "ctrl+c":
++ 		return m, m.closeSettings()
++ 	case "up", "k", "ctrl+p", "shift+tab":
++ 		m.moveSettingRow(-1)
++ 	case "down", "j", "ctrl+n", "tab":
++ 		m.moveSettingRow(1)
++ 	case "left", "h":
++ 		m.cycleSetting(m.setIdx, -1)
++ 	case "right", "l", " ":
++ 		m.cycleSetting(m.setIdx, 1)
++ 	case "enter":
++ 		// The model row is the one setting whose choices this build does not
++ 		// know: they come from whatever the endpoint serves. So enter hands
++ 		// over to the picker that asks it, rather than cycling a list that
++ 		// could not name the model a gateway is actually running.
++ 		if m.setIdx == setModelRow {
++ 			m.setFrom = true
++ 			return m, m.openModelPicker()
++ 		}
++ 		m.cycleSetting(m.setIdx, 1)
++ 	default:
++ 		// A digit jumps to a row, the way it picks a model or an effort level
++ 		// in the other two panels.
++ 		if len(key) == 1 && key[0] >= '1' && key[0] <= '9' {
++ 			if i := int(key[0] - '1'); i < int(numSettingRows) {
++ 				m.setIdx = settingRow(i)
++ 			}
++ 		}
++ 	}
++ 	return m, m.sync()
++ }
++ // moveSettingRow walks the list. It stops at the ends rather than wrapping:
++ // the rows are a list to read, not a dial, and the values wrap already.
++ func (m *model) moveSettingRow(d int) {
++ 	m.setIdx = settingRow(clampIdx(int(m.setIdx)+d, int(numSettingRows)))
++ }
++ // closeSettings puts the prompt back and saves, if there is anything to save.
++ //
++ // There is no cancel: every change has already been applied to the running
++ // session as it was made, which is the point of a panel you watch the theme
++ // change under. Leaving is therefore only ever about the file.
++ func (m *model) closeSettings() tea.Cmd {
++ 	m.phase = phaseIdle
++ 	m.input.Focus()
++ 	themed := m.setTouched[setThemeRow]
++ 	cfg := m.settingsConfig()
++ 	m.setTouched = [numSettingRows]bool{}
++ 	if cfg == m.opts.Config {
++ 		// Nothing was changed, or it was changed back. Leaving must not
++ 		// rewrite the file, and it is not worth a line of scrollback either.
++ 		return tea.Batch(m.sync(), textarea.Blink)
++ 	}
++ 	m.opts.Config = cfg
++ 	// The setup marker is deliberately not stamped here. It means "the
++ 	// questions were all asked and answered", and this panel does not ask
++ 	// them: someone who has only ever changed their theme has not been
++ 	// through setup, and should still be offered it.
++ 	note := "settings saved: " + settingsSummary(cfg)
++ 	if m.opts.SaveConfig != nil {
++ 		if err := m.opts.SaveConfig(cfg); err != nil {
++ 			// The settings are already in force; only the file failed.
++ 			note = "settings: " + settingsSummary(cfg) +
++ 				"\nthese are in force for this session, but saving them failed: " + err.Error()
++ 		}
++ 	}
++ 	m.tr.addNotice(note)
++ 	if themed {
++ 		// Every entry was laid out in the old palette.
++ 		m.refreshSplash()
++ 	}
++ 	return tea.Batch(m.sync(), textarea.Blink)
++ }
++ // settingsConfig is the config as the panel would save it: what was loaded,
++ // with the rows that were actually touched replaced by what is now in force.
++ //
++ // Only the touched rows, rather than all four, because the panel shows the
++ // session and the session is not always the file. -yolo turns accept-all on
++ // for one run; a panel that read it back off the policy would quietly write
++ // "run everything without asking" into the config of someone who asked for it
++ // once, on the command line, for one session.
++ func (m *model) settingsConfig() config.Config {
++ 	cfg := m.opts.Config
++ 	for r := settingRow(0); r < numSettingRows; r++ {
++ 		if !m.settingTouched(r) {
++ 			continue
++ 		}
++ 		v := m.settingValue(r)
++ 		switch r {
++ 		case setModelRow:
++ 			cfg.Model = v
++ 		case setEffortRow:
++ 			cfg.Effort = v
++ 		case setApprovalsRow:
++ 			cfg.Approvals = v
++ 		case setThemeRow:
++ 			cfg.Theme = v
++ 		}
++ 	}
++ 	return cfg
++ }
++ func settingsSummary(cfg config.Config) string {
++ 	return prettyModel(cfg.Model) + " · effort " + config.Or(cfg.Effort, defaultEffort) +
++ 		" · approvals " + config.Or(cfg.Approvals, config.ApprovalsAsk) +
++ 		" · " + config.Or(cfg.Theme, currentTheme.name) + " theme"
++ }
++ // settingTouched reports whether a row was changed while the panel has been
++ // open, which is the only thing that gets written back.
++ func (m *model) settingTouched(r settingRow) bool {
++ 	if r == setModelRow {
++ 		// The model is changed through the picker the panel hands over to, so
++ 		// there is no keystroke here to have recorded. What it was when the
++ 		// panel opened is the whole test, and asking at this point rather than
++ 		// as the picker closes keeps it out of the order those two do their
++ 		// work in.
++ 		return m.modelInForce() != m.setModelWas
++ 	}
++ 	return m.setTouched[r]
++ }
++ // settingValue is what a row is set to right now. It reads the session rather
++ // than the config, because the session is what the panel is showing: /effort,
++ // shift+tab and -yolo all change a setting without the file hearing about it,
++ // and a panel that disagreed with the status bar would be worse than useless.
++ func (m *model) settingValue(r settingRow) string {
++ 	switch r {
++ 	case setModelRow:
++ 		return m.modelInForce()
++ 	case setEffortRow:
++ 		if m.opts.Effort == "" {
++ 			return defaultEffort
++ 		}
++ 		return m.opts.Effort
++ 	case setApprovalsRow:
++ 		if m.opts.Policy != nil && m.opts.Policy.YOLO {
++ 			return config.ApprovalsAcceptAll
++ 		}
++ 		return config.ApprovalsAsk
++ 	case setThemeRow:
++ 		return currentTheme.name
++ 	}
++ 	return ""
++ }
++ func (m *model) modelInForce() string {
++ 	if m.opts.Client == nil {
++ 		return ""
++ 	}
++ 	return m.opts.Client.Model()
++ }
++ // settingOptions is what a row cycles through. The model row has none: its
++ // choices come from the endpoint, through the picker.
++ func settingOptions(r settingRow) []wizOption {
++ 	switch r {
++ 	case setEffortRow:
++ 		return effortOptions()
++ 	case setApprovalsRow:
++ 		return approvalOptions()
++ 	case setThemeRow:
++ 		return themeOptions()
++ 	}
++ 	return nil
++ }
++ // cycleSetting moves a row to its next value and applies it there and then.
++ // It wraps: these are short lists, and a row that stops at one end reads as a
++ // row that has stopped working.
++ func (m *model) cycleSetting(r settingRow, d int) {
++ 	opts := settingOptions(r)
++ 	if len(opts) == 0 {
++ 		return
++ 	}
++ 	i := (optionIndex(opts, m.settingValue(r)) + d + len(opts)) % len(opts)
++ 	m.useSetting(r, opts[i].value)
++ }
++ // useSetting applies a value to the running session. It goes through the same
++ // setters /effort, shift+tab and the wizard use, so a setting changed here and
++ // the same setting changed from the prompt cannot come out different.
++ //
++ // The quiet setters are the ones used, not the announcing ones: the panel is
++ // on screen showing the value, and cycling past four themes should not cost
++ // four lines of transcript.
++ func (m *model) useSetting(r settingRow, v string) {
++ 	switch r {
++ 	case setEffortRow:
++ 		m.useEffort(v)
++ 	case setApprovalsRow:
++ 		if m.opts.Policy != nil {
++ 			m.opts.Policy.YOLO = v == config.ApprovalsAcceptAll
++ 		}
++ 	case setThemeRow:
++ 		applyTheme(v)
++ 	}
++ 	m.setTouched[r] = true
++ }
++ // backFromPicker is where the model picker goes when it is done: back to the
++ // settings panel when that is what opened it, and to the prompt otherwise.
++ func (m *model) backFromPicker() phase {
++ 	if !m.setFrom {
++ 		return phaseIdle
++ 	}
++ 	m.setFrom = false
++ 	return phaseSettings
++ }
++ // ---- view ---------------------------------------------------------------
++ // settingsView is the panel: a heading with the keys, a row per setting, a
++ // sentence about the row under the cursor, and where all of it is saved.
++ //
++ //	Settings                                  ↑↓ row · ←→ change · esc done
++ //	❯ Model       Claude Sonnet 5             $3 / $15 per Mtok
++ //	  Effort      high                        default
++ //	  Approvals   Ask me first                recommended
++ //	  Theme       ember
++ //	  the model every turn is sent to · enter to pick from api.anthropic.com
++ //	  saved to ~/.config/harness/config.json
++ func (m *model) settingsView() string {
++ 	width := maxInt(1, m.width)
++ 	var b strings.Builder
++ 	b.WriteString(spread(" "+styHeading.Render("Settings"),
++ 		styFaint.Render("↑↓ row · ←→ change · esc done"), width))
++ 	// Wide enough for the longest label and a gap after it, so the values line
++ 	// up in a column of their own rather than against the widest word.
++ 	const labelCol = 12
++ 	valueCol := 0
++ 	values := make([]string, numSettingRows)
++ 	for r := settingRow(0); r < numSettingRows; r++ {
++ 		values[r] = m.settingLabel(r)
++ 		valueCol = maxInt(valueCol, lipgloss.Width(values[r]))
++ 	}
++ 	valueCol = minInt(valueCol, maxInt(10, width/3))
++ 	for r := settingRow(0); r < numSettingRows; r++ {
++ 		marker, style := "  ", styDim
++ 		if r == m.setIdx {
++ 			marker, style = styKey.Render("❯ "), styKey
++ 		}
++ 		line := marker + styFaint.Render(pad(settingLabels[r], labelCol)) +
++ 			style.Render(pad(values[r], valueCol)) + "  " + styFaint.Render(m.settingNote(r))
++ 		b.WriteString("\n" + truncateStyled(" "+line, width))
++ 	}
++ 	b.WriteString("\n" + truncateStyled("   "+styDim.Render(m.settingDetail(m.setIdx)), width))
++ 	// Where it lands is on screen because "where did that go?" is the first
++ 	// question a panel that saves by itself has to answer. It is the same
++ 	// label the wizard signs off with.
++ 	b.WriteString("\n" + truncateStyled("   "+styFaint.Render("saved to "+configPathLabel()), width))
++ 	return b.String()
++ }
++ // settingLabel is how a row's value is spelled on screen: the option's own
++ // label where there is one, so the panel and the wizard say the same words.
++ func (m *model) settingLabel(r settingRow) string {
++ 	v := m.settingValue(r)
++ 	if r == setModelRow {
++ 		return prettyModel(v)
++ 	}
++ 	for _, o := range settingOptions(r) {
++ 		if o.value == v {
++ 			return o.label
++ 		}
++ 	}
++ 	return v
++ }
++ // settingNote is the short fact in the right-hand column — a price, which
++ // level the API would have picked anyway — kept to the width of a glance.
++ func (m *model) settingNote(r settingRow) string {
++ 	if r == setModelRow {
++ 		return priceLabel(m.settingValue(r))
++ 	}
++ 	v := m.settingValue(r)
++ 	for _, o := range settingOptions(r) {
++ 		if o.value == v {
++ 			return o.note
++ 		}
++ 	}
++ 	return ""
++ }
++ // settingDetail is the sentence about the row under the cursor. It is one line
++ // for the whole panel rather than one per row, so the list stays scannable —
++ // the same trade the wizard makes.
++ func (m *model) settingDetail(r settingRow) string {
++ 	if r == setModelRow {
++ 		detail := m.settingValue(r)
++ 		if detail == "" {
++ 			detail = "no model set"
++ 		}
++ 		if m.opts.Client != nil {
++ 			detail += " · enter to pick from " + endpointLabel(m.opts.Client)
++ 		}
++ 		return detail
++ 	}
++ 	v := m.settingValue(r)
++ 	for _, o := range settingOptions(r) {
++ 		if o.value == v {
++ 			return o.desc
++ 		}
++ 	}
++ 	return ""
++ }

+352−0internal/tui/settings_test.goaddedView File

++ package tui
++ import (
++ 	"context"
++ 	"errors"
++ 	"strings"
++ 	"testing"
++ 	tea "github.com/charmbracelet/bubbletea"
++ 	"github.com/charmbracelet/lipgloss"
++ 	"harness/internal/approval"
++ 	"harness/internal/config"
++ 	"harness/internal/llm"
++ )
++ // newSettingsModel builds a chat model with a config already on disk and a
++ // SaveConfig that records rather than writes. The returned pointer is nil
++ // until the panel saves something, which is what most of these tests are
++ // about.
++ func newSettingsModel(t *testing.T, cur config.Config) (*model, **config.Config) {
++ 	t.Helper()
++ 	t.Cleanup(func() { applyTheme(defaultTheme) })
++ 	var saved *config.Config
++ 	m := newModel(context.Background(), Options{
++ 		Client: llm.New(llm.WithAPIKey("x")),
++ 		Root:   "/tmp/repo",
++ 		Policy: approval.New(nil),
++ 		Config: cur,
++ 		SaveConfig: func(c config.Config) error {
++ 			saved = &c
++ 			return nil
++ 		},
++ 	})
++ 	m.Update(tea.WindowSizeMsg{Width: 100, Height: 40})
++ 	return m, &saved
++ }
++ // open puts the panel up the way a person does.
++ func openSettingsPanel(t *testing.T, m *model) {
++ 	t.Helper()
++ 	m.submit("/settings")
++ 	if m.phase != phaseSettings {
++ 		t.Fatalf("/settings left the model in phase %v", m.phase)
++ 	}
++ }
++ // The walk the panel exists for: change one thing, leave, and find it both in
++ // force and in the file.
++ func TestSettingsChangeAppliesAndSaves(t *testing.T) {
++ 	m, saved := newSettingsModel(t, config.Config{Effort: "high", Theme: "ember", Setup: config.SetupDone})
++ 	openSettingsPanel(t, m)
++ 	m.Update(key("down")) // → effort
++ 	if m.setIdx != setEffortRow {
++ 		t.Fatalf("down from the model row landed on %v", m.setIdx)
++ 	}
++ 	m.Update(key("right"))
++ 	want := m.opts.Effort
++ 	if want == "high" {
++ 		t.Fatal("cycling the effort row did not change the level in force")
++ 	}
++ 	m.Update(key("esc"))
++ 	if m.phase != phaseIdle {
++ 		t.Fatalf("esc did not close the panel: phase %v", m.phase)
++ 	}
++ 	if *saved == nil {
++ 		t.Fatal("leaving the panel saved nothing")
++ 	}
++ 	if (*saved).Effort != want {
++ 		t.Errorf("saved effort %q, want the %q that is in force", (*saved).Effort, want)
++ 	}
++ 	if !(*saved).Done() {
++ 		t.Error("the panel dropped the setup marker that was already in the file")
++ 	}
++ 	if !strings.Contains(m.tr.render(), "settings saved") {
++ 		t.Error("the change was never reported in the transcript")
++ 	}
++ }
++ // A theme is applied as you move onto it, not when you leave: the whole point
++ // of a panel over a wizard step is watching the transcript change colour.
++ func TestSettingsThemeAppliesWhileYouCycle(t *testing.T) {
++ 	m, saved := newSettingsModel(t, config.Config{Theme: "ember"})
++ 	openSettingsPanel(t, m)
++ 	m.setIdx = setThemeRow
++ 	m.Update(key("right"))
++ 	if currentTheme.name == "ember" {
++ 		t.Fatal("cycling the theme row did not repaint")
++ 	}
++ 	previewed := currentTheme.name
++ 	m.Update(key("esc"))
++ 	if currentTheme.name != previewed {
++ 		t.Errorf("leaving the panel undid the theme: %q, want %q", currentTheme.name, previewed)
++ 	}
++ 	if *saved == nil || (*saved).Theme != previewed {
++ 		t.Errorf("the previewed theme was not saved: %+v", *saved)
++ 	}
++ }
++ // Browsing is not editing. Opening the panel, walking every row and leaving
++ // must not rewrite the file — and must not say it did.
++ func TestSettingsSavesNothingWhenNothingChanged(t *testing.T) {
++ 	m, saved := newSettingsModel(t, config.Config{Effort: "low", Theme: "mint", Setup: config.SetupDone})
++ 	openSettingsPanel(t, m)
++ 	for i := 0; i < int(numSettingRows)+2; i++ {
++ 		m.Update(key("down"))
++ 	}
++ 	for i := 0; i < int(numSettingRows)+2; i++ {
++ 		m.Update(key("up"))
++ 	}
++ 	m.Update(key("esc"))
++ 	if *saved != nil {
++ 		t.Errorf("walking the panel rewrote the config: %+v", *saved)
++ 	}
++ 	if strings.Contains(m.tr.render(), "settings saved") {
++ 		t.Error("nothing changed, but the panel said it saved")
++ 	}
++ }
++ // A value cycled back to where it started is not a change either.
++ func TestSettingsSavesNothingWhenCycledBack(t *testing.T) {
++ 	m, saved := newSettingsModel(t, config.Config{Theme: "ember", Setup: config.SetupDone})
++ 	openSettingsPanel(t, m)
++ 	m.setIdx = setThemeRow
++ 	for range themeOptions() {
++ 		m.Update(key("right"))
++ 	}
++ 	if currentTheme.name != "ember" {
++ 		t.Fatalf("a full cycle did not come back to ember: %q", currentTheme.name)
++ 	}
++ 	m.Update(key("esc"))
++ 	if *saved != nil {
++ 		t.Errorf("a value cycled back to itself was still written: %+v", *saved)
++ 	}
++ }
++ // -yolo is a decision about one session, taken on the command line. Somebody
++ // who opens the panel on such a session to change their theme must not find
++ // "run everything without asking" written into their config afterwards.
++ func TestSettingsDoesNotPersistAnApprovalModeItWasNotAsked(t *testing.T) {
++ 	m, saved := newSettingsModel(t, config.Config{Theme: "ember", Approvals: config.ApprovalsAsk})
++ 	m.opts.Policy.YOLO = true // as -yolo leaves it
++ 	openSettingsPanel(t, m)
++ 	m.setIdx = setThemeRow
++ 	m.Update(key("right"))
++ 	m.Update(key("esc"))
++ 	if *saved == nil {
++ 		t.Fatal("the theme change was not saved")
++ 	}
++ 	if (*saved).Approvals != config.ApprovalsAsk {
++ 		t.Errorf("the session's -yolo was written to the config: %q", (*saved).Approvals)
++ 	}
++ }
++ // Changing approvals in the panel does take, both in the file and in the
++ // policy the agent actually consults.
++ func TestSettingsApprovalsReachThePolicy(t *testing.T) {
++ 	m, saved := newSettingsModel(t, config.Config{Approvals: config.ApprovalsAsk, Setup: config.SetupDone})
++ 	openSettingsPanel(t, m)
++ 	m.setIdx = setApprovalsRow
++ 	m.Update(key("right"))
++ 	if !m.opts.Policy.YOLO {
++ 		t.Fatal("cycling to accept-all did not reach the policy")
++ 	}
++ 	m.Update(key("esc"))
++ 	if *saved == nil || (*saved).Approvals != config.ApprovalsAcceptAll {
++ 		t.Errorf("accept-all was not saved: %+v", *saved)
++ 	}
++ }
++ // The panel shows the session, not the file: /effort five minutes ago is what
++ // the effort row has to say, or the two disagree in front of the user.
++ func TestSettingsShowsWhatTheSessionIsRunning(t *testing.T) {
++ 	m, _ := newSettingsModel(t, config.Config{Effort: "low", Model: "claude-opus-5"})
++ 	m.useEffort("max")
++ 	m.opts.Client.SetModel("claude-haiku-4-5")
++ 	openSettingsPanel(t, m)
++ 	view := m.settingsView()
++ 	for _, want := range []string{"max", prettyModel("claude-haiku-4-5")} {
++ 		if !strings.Contains(view, want) {
++ 			t.Errorf("the panel does not report %q:\n%s", want, view)
++ 		}
++ 	}
++ }
++ // The model row is the one that cannot cycle: its choices come from the
++ // endpoint, so enter hands over to the picker and the picker comes back here.
++ func TestSettingsModelRowOpensThePickerAndReturns(t *testing.T) {
++ 	m, saved := newSettingsModel(t, config.Config{Model: "claude-opus-5", Setup: config.SetupDone})
++ 	openSettingsPanel(t, m)
++ 	m.Update(key("right")) // the model row does not cycle
++ 	if m.opts.Client.Model() != "claude-opus-5" {
++ 		t.Errorf("the model row cycled to %q", m.opts.Client.Model())
++ 	}
++ 	m.Update(key("enter"))
++ 	if m.phase != phaseModel {
++ 		t.Fatalf("enter on the model row left the model in phase %v", m.phase)
++ 	}
++ 	m.Update(modelsMsg{models: []llm.Model{
++ 		{ID: "claude-opus-5", DisplayName: "Claude Opus 5"},
++ 		{ID: "claude-sonnet-5", DisplayName: "Claude Sonnet 5"},
++ 	}})
++ 	m.Update(key("down"))
++ 	m.Update(key("enter"))
++ 	if m.phase != phaseSettings {
++ 		t.Fatalf("the picker did not come back to the panel: phase %v", m.phase)
++ 	}
++ 	if m.opts.Client.Model() != "claude-sonnet-5" {
++ 		t.Fatalf("the picked model did not take: %q", m.opts.Client.Model())
++ 	}
++ 	m.Update(key("esc"))
++ 	if *saved == nil || (*saved).Model != "claude-sonnet-5" {
++ 		t.Errorf("the picked model was not saved: %+v", *saved)
++ 	}
++ }
++ // Escaping the picker is not choosing a model, and must leave the panel with
++ // nothing to save.
++ func TestSettingsPickerEscapeReturnsWithoutChanging(t *testing.T) {
++ 	m, saved := newSettingsModel(t, config.Config{Model: "claude-opus-5", Setup: config.SetupDone})
++ 	openSettingsPanel(t, m)
++ 	m.Update(key("enter"))
++ 	m.Update(modelsMsg{models: []llm.Model{{ID: "claude-opus-5"}, {ID: "claude-sonnet-5"}}})
++ 	m.Update(key("esc"))
++ 	if m.phase != phaseSettings {
++ 		t.Fatalf("esc in the picker did not return to the panel: phase %v", m.phase)
++ 	}
++ 	m.Update(key("esc"))
++ 	if *saved != nil {
++ 		t.Errorf("an escaped picker still wrote the config: %+v", *saved)
++ 	}
++ }
++ // /model opened from the prompt has nothing to do with the panel and must
++ // still land back at the prompt.
++ func TestModelPickerStillReturnsToThePrompt(t *testing.T) {
++ 	m, _ := newSettingsModel(t, config.Config{Model: "claude-opus-5"})
++ 	m.submit("/model")
++ 	m.Update(modelsMsg{models: []llm.Model{{ID: "claude-opus-5"}}})
++ 	m.Update(key("enter"))
++ 	if m.phase != phaseIdle {
++ 		t.Errorf("the picker returned to phase %v rather than the prompt", m.phase)
++ 	}
++ }
++ // The settings are already in force by the time the file is written, so a
++ // failed write is a warning, not a lost change.
++ func TestSettingsReportsAFailedSave(t *testing.T) {
++ 	m, _ := newSettingsModel(t, config.Config{Theme: "ember"})
++ 	m.opts.SaveConfig = func(config.Config) error { return errors.New("disk is full") }
++ 	openSettingsPanel(t, m)
++ 	m.setIdx = setThemeRow
++ 	m.Update(key("right"))
++ 	applied := currentTheme.name
++ 	m.Update(key("esc"))
++ 	if currentTheme.name != applied {
++ 		t.Error("a failed save undid the change it failed to record")
++ 	}
++ 	if !strings.Contains(m.tr.render(), "disk is full") {
++ 		t.Errorf("a failed save was not reported:\n%s", m.tr.render())
++ 	}
++ }
++ // The panel is not the wizard: changing a theme is not answering the setup
++ // questions, so somebody who has never seen the wizard still gets it.
++ func TestSettingsDoesNotMarkTheSetupDone(t *testing.T) {
++ 	m, saved := newSettingsModel(t, config.Config{})
++ 	openSettingsPanel(t, m)
++ 	m.setIdx = setThemeRow
++ 	m.Update(key("right"))
++ 	m.Update(key("esc"))
++ 	if *saved == nil {
++ 		t.Fatal("the theme change was not saved")
++ 	}
++ 	if (*saved).Done() {
++ 		t.Error("the settings panel claimed the setup was finished")
++ 	}
++ }
++ // A click on a row is a choice, the way it is everywhere else in the chrome.
++ func TestSettingsClickPicksTheRowUnderThePointer(t *testing.T) {
++ 	m, _ := newSettingsModel(t, config.Config{Theme: "ember"})
++ 	openSettingsPanel(t, m)
++ 	secs := m.layout()
++ 	top := maxInt(1, m.height-rowsOf(secs))
++ 	// The rows start under the heading, and the panel is the second section.
++ 	row := top + lipgloss.Height(secs[0].text) + settingsHeadRows + int(setThemeRow)
++ 	m.Update(tea.MouseMsg{X: 4, Y: row, Action: tea.MouseActionPress, Button: tea.MouseButtonLeft})
++ 	if m.setIdx != setThemeRow {
++ 		t.Fatalf("the click landed on row %v, want the theme row", m.setIdx)
++ 	}
++ 	if currentTheme.name == "ember" {
++ 		t.Error("clicking a row did not change its value")
++ 	}
++ }
++ // Every row has to be spelled out, or the panel is a list of blanks.
++ func TestSettingsViewNamesEveryRow(t *testing.T) {
++ 	m, _ := newSettingsModel(t, config.Config{Effort: "high", Theme: "ember"})
++ 	openSettingsPanel(t, m)
++ 	view := m.settingsView()
++ 	for r := settingRow(0); r < numSettingRows; r++ {
++ 		if !strings.Contains(view, settingLabels[r]) {
++ 			t.Errorf("the panel does not name the %s row:\n%s", settingLabels[r], view)
++ 		}
++ 		if m.settingLabel(r) == "" {
++ 			t.Errorf("the %s row has no value to show", settingLabels[r])
++ 		}
++ 	}
++ 	if !strings.Contains(view, "saved to") {
++ 		t.Error("the panel does not say where it saves")
++ 	}
++ }
++ // A narrow terminal must not panic the renderer, the way every other piece of
++ // chrome is expected to survive one.
++ func TestSettingsViewSurvivesANarrowScreen(t *testing.T) {
++ 	m, _ := newSettingsModel(t, config.Config{})
++ 	openSettingsPanel(t, m)
++ 	for _, w := range []int{1, 8, 20, 40} {
++ 		m.Update(tea.WindowSizeMsg{Width: w, Height: 20})
++ 		for _, line := range strings.Split(m.settingsView(), "\n") {
++ 			if lipgloss.Width(line) > w {
++ 				t.Errorf("width %d: a line is %d wide: %q", w, lipgloss.Width(line), line)
++ 			}
++ 		}
++ 	}
++ }

+12−0internal/tui/wizard.goView File

@@ -428,6 +428,14 @@ func (w *wizard) current() string {
428	428	}
429	429
430	430	func (w *wizard) indexOf(opts []wizOption, value string) int {
	431	+ return optionIndex(opts, value)
	432	+ }
	433	+
	434	+ // optionIndex is where a value sits in a list of options, or the top of the
	435	+ // list when it is not in it at all — which is what preselecting a setting this
	436	+ // build no longer offers has to fall back to. The settings panel cycles the
	437	+ // same lists, so the lookup is shared rather than written twice.
	438	+ func optionIndex(opts []wizOption, value string) int {
431	439	for i, o := range opts {
432	440	if o.value == value {
433	441	return i
@@ -436,8 +444,12 @@ func (w *wizard) indexOf(opts []wizOption, value string) int {
436	444	return 0
437	445	}
438	446
	447	+ // finish seals the answers. The marker is stamped here rather than by
	448	+ // whatever saves the file: it means "these questions were all asked and
	449	+ // answered", which is a thing only the wizard is in a position to say.
439	450	func (w *wizard) finish() {
440	451	cfg := w.cfg
	452	+ cfg.Setup = config.SetupDone
441	453	w.result = &cfg
442	454	}
443	455

+34−4internal/tui/wizard_test.goView File

@@ -118,8 +118,32 @@ func TestWizardPreselectsWhatIsAlreadyConfigured(t *testing.T) {
118	118	if w.result == nil {
119	119	t.Fatal("four enters did not finish the wizard")
120	120	}
121		- if *w.result != cur {
122		- t.Errorf("accepting every default changed the config:\n got %+v\nwant %+v", *w.result, cur)
	121	+ want := cur
	122	+ want.Setup = config.SetupDone // the one thing finishing does add
	123	+ if *w.result != want {
	124	+ t.Errorf("accepting every default changed the config:\n got %+v\nwant %+v", *w.result, want)
	125	+ }
	126	+ }
	127	+
	128	+ // Finishing is what the marker means, so it must come back on the result and
	129	+ // not be something the wizard hands out before the last question is answered.
	130	+ func TestWizardMarksTheSetupDoneOnlyWhenItFinishes(t *testing.T) {
	131	+ w := newTestWizard(t, config.Config{})
	132	+ w.Update(key("enter")) // → model
	133	+ w.Update(key("enter")) // → effort
	134	+ if w.cfg.Setup != "" {
	135	+ t.Errorf("the setup was marked done two questions in: %q", w.cfg.Setup)
	136	+ }
	137	+
	138	+ for i := 0; i < 5 && w.result == nil; i++ {
	139	+ w.Update(key("enter"))
	140	+ settle(w)
	141	+ }
	142	+ if w.result == nil {
	143	+ t.Fatal("the wizard did not finish")
	144	+ }
	145	+ if !w.result.Done() {
	146	+ t.Errorf("a finished wizard did not mark the setup done: %+v", *w.result)
123	147	}
124	148	}
125	149
@@ -377,8 +401,14 @@ func TestSetupIsInTheCommandCatalogue(t *testing.T) {
377	401	if !strings.Contains(m.helpText(), "/setup") {
378	402	t.Error("/help does not list /setup")
379	403	}
380		- if got := matchCommands(m.commands(), "set"); len(got) == 0 \|\| got[0].name != "setup" {
381		- t.Errorf("typing /set does not offer /setup first: %v", got)
	404	+ // /set is a prefix of both, and the menu offers them in catalogue order:
	405	+ // /settings first, because it is the one reached for more than once. One
	406	+ // letter more is unambiguous, which is what has to keep working.
	407	+ if got := matchCommands(m.commands(), "setu"); len(got) == 0 \|\| got[0].name != "setup" {
	408	+ t.Errorf("typing /setu does not offer /setup first: %v", got)
	409	+ }
	410	+ if got := matchCommands(m.commands(), "sett"); len(got) == 0 \|\| got[0].name != "settings" {
	411	+ t.Errorf("typing /sett does not offer /settings first: %v", got)
382	412	}
383	413	}
384	414