johannSoCodeyPublic

Merge master: compaction meets the settings panel

Both sides added a key to the config and a row to the command list, in
the same three places. Nothing disagreed — /settings and /compact are
unrelated — so the resolution is to keep both everywhere: setup and
auto_compact side by side in Config and in sanitize, both sets of tests,
both commands in the README's list.

The one thing worth checking rather than merging was whether the panel
can lose the new key. It cannot: settingsConfig starts from the config
as loaded and overwrites only the rows that were touched, so a field it
has no row for comes through whatever you do in it. That is true by
construction today and easy to break later, so it now has a test, as the
wizard already did for the same reason.

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

Browse Files

Jjonicommitted 4 weeks ago2 parents 74cbf71 c23aec0commit93ba06d

Showing 12 changed files with 984 additions and 29 deletions.

Merge commit — showing changes against the first parent.

+54−11README.mdView File

@@ -171,7 +171,8 @@ compaction stops being optional, and it can be turned off altogether: see
171	171	\| `ctrl+c` \| interrupt the turn; again when idle to exit \|
172	172
173	173	Commands: `/allowed`, `/clear`, `/compact`, `/effort`, `/exit`, `/help`,
174		- `/model`, `/mouse`, `/setup`, `/skills`, and one per discovered skill.
	174	+ `/model`, `/mouse`, `/settings`, `/setup`, `/skills`, and one per discovered
	175	+ skill.
175	176
176	177	### The mouse
177	178
@@ -304,8 +305,8 @@ force shows above the prompt on the right. A terminal too narrow for five
304	305	labels gets `◀ high ▶` and the same keys rather than a track with the words
305	306	sliced in half.
306	307
307		- `/model` and `/effort` change the session. `/setup` changes what the next
308		- session starts with — see [Setup](#setup).
	308	+ `/model` and `/effort` change the session. `/settings` and `/setup` change what
	309	+ the next session starts with — see [Setup](#setup).
309	310
310	311	`shift+tab` cycles between asking before every mutating call and accepting them
311	312	all, which is `-yolo` reached from the keyboard. The mode line says which is in
@@ -327,6 +328,10 @@ cannot.
327	328
328	329	The first run on a terminal opens a full-screen wizard instead of the chat: the
329	330	mark assembles, the name lights up, and it asks four questions one at a time.
	331	+ "First run" means the config file does not say `"setup": "done"` — the marker
	332	+ the wizard stamps when the last question is answered — rather than that no file
	333	+ exists, so a config written by hand, or by a build with fewer questions in it,
	334	+ still gets asked the ones it is missing.
330	335
331	336	```
332	337	harness setup step 1 of 4
@@ -373,14 +378,17 @@ honoured):
373	378	"effort": "high",
374	379	"approvals": "ask",
375	380	"theme": "ember",
376		- "auto_compact": "on"
	381	+ "auto_compact": "on",
	382	+ "setup": "done"
377	383	}
378	384	```
379	385
380		- `auto_compact` is the one key the wizard does not ask about — set it by hand, or
381		- pass `-no-auto-compact` for a single run. Set to `"off"`, the conversation is
382		- never folded on its own: the window becomes a wall rather than a trigger, and at
383		- `-compact-floor` the turn stops before sending a request that would not fit,
	386	+ `auto_compact` is the one key neither the wizard nor `/settings` offers a row
	387	+ for — set it by hand, or pass `-no-auto-compact` for a single run. Both screens
	388	+ write the whole file but only touch what they asked about, so it survives them.
	389	+ Set to `"off"`, the conversation is never folded on its own: the window becomes
	390	+ a wall rather than a trigger, and at `-compact-floor` the turn stops before
	391	+ sending a request that would not fit,
384	392	naming `/compact` and `/clear` as the ways on. The prompt is refused before it
385	393	joins the history, so compacting and asking again sends it once rather than
386	394	twice. `/compact` keeps working throughout — the setting governs the automatic
@@ -408,9 +416,44 @@ model than it started. A config file that cannot be parsed is reported and then
408	416	ignored, and is never overwritten until you finish the wizard.
409	417
410	418	`/model` and `/effort` change the running session and say "from the next turn
411		- on"; they do not write to the file. The wizard is the thing that decides what
412		- the next session starts with, which is why it is a separate screen rather
413		- than a fourth picker.
	419	+ on"; they do not write to the file. The two screens that do are the wizard and
	420	+ `/settings`.
	421	+
	422	+ ### /settings
	423	+
	424	+ `/settings` is the same four settings without the interview: one row each,
	425	+ changed in place, applied as you move.
	426	+
	427	+ ```
	428	+ Settings ↑↓ row · ←→ change · esc done
	429	+ ❯ Model Opus 5 $5 / $25 per Mtok
	430	+ Effort high default
	431	+ Approvals Ask me first recommended
	432	+ Theme ember
	433	+ claude-opus-5 · enter to pick from anthropic
	434	+ saved to ~/.config/harness/config.json
	435	+ ```
	436	+
	437	+ `←→` cycles a row and applies it there and then — the theme repaints under the
	438	+ panel, the way it previews in the wizard — and `esc` closes and writes the
	439	+ file. There is no cancel, because there is nothing left to confirm: the session
	440	+ already has every change. A panel that was only read leaves the file alone, and
	441	+ so does a value cycled back to where it started.
	442	+
	443	+ The rows come from the same option lists the wizard's steps are built from, so
	444	+ neither screen can invent a name for a theme or a sentence about an effort
	445	+ level the other does not use. The model row is the exception: its choices come
	446	+ from the endpoint rather than from this build, so `enter` hands over to the
	447	+ `/model` picker and lands back here once you have chosen.
	448	+
	449	+ What the panel shows is the session, not the file — `/effort`, `shift+tab`
	450	+ and `-yolo` all change a setting without the file hearing about it, and a panel
	451	+ that disagreed with the status bar two lines below it would be worse than
	452	+ useless. Only the rows actually touched are written back, which is what keeps a
	453	+ `-yolo` run from quietly saving "accept everything" as the default for every
	454	+ run after it. And the setup marker is not stamped here: changing a theme is
	455	+ not answering the setup questions, so someone who has only ever used this panel
	456	+ is still offered the wizard.
414	457
415	458	The whole thing is `↑↓` and `enter`, `esc` to go back. Animations collapse to
416	459	their final frame under `NO_COLOR`, a `dumb` terminal, or a window under 60×20,

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

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

+25−3internal/config/config.goView File

@@ -32,9 +32,14 @@ const (
32	32	ApprovalsAcceptAll = "accept-all"
33	33	)
34	34
35		- // Auto-compaction settings, as written to the file. Spelled out rather than
36		- // stored as a bool for the same reason the approval modes are: an empty value
37		- // has to mean "no preference", and a bool cannot tell that apart from "off".
	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	+
	40	+ // Auto-compaction settings, as written to the file. Spelled out for the same
	41	+ // reason again: an empty value has to mean "no preference", and a bool cannot
	42	+ // tell that apart from "off".
38	43	const (
39	44	AutoCompactOn = "on"
40	45	AutoCompactOff = "off"
@@ -63,12 +68,24 @@ type Config struct {
63	68	// config written before this setting existed must not quietly start
64	69	// stopping the agent at a full window.
65	70	AutoCompact string `json:"auto_compact,omitempty"`
	71	+ // Setup is SetupDone once the questions have been answered to the end.
	72	+ //
	73	+ // It is what decides whether the wizard opens by itself, in place of the
	74	+ // older test of whether the file exists at all. The difference shows up on
	75	+ // a config that exists but was never finished — written by hand, or by a
	76	+ // build that had fewer questions in it — where "the file is there" would
	77	+ // say the setup was done and this says who says so.
	78	+ Setup string `json:"setup,omitempty"`
66	79	}
67	80
68	81	// AutoCompactEnabled reports whether the conversation should fold itself when
69	82	// the window fills. Only an explicit "off" turns it off.
70	83	func (c Config) AutoCompactEnabled() bool { return c.AutoCompact != AutoCompactOff }
71	84
	85	+ // Done reports whether the setup has been completed. It is the only thing
	86	+ // that suppresses the wizard on startup.
	87	+ func (c Config) Done() bool { return c.Setup == SetupDone }
	88	+
72	89	// Path is where the config lives: $XDG_CONFIG_HOME/harness/config.json, or
73	90	// ~/.config/harness/config.json when XDG_CONFIG_HOME is unset.
74	91	func Path() (string, error) {
@@ -126,6 +143,11 @@ func sanitize(c Config) Config {
126	143	if c.AutoCompact != AutoCompactOn && c.AutoCompact != AutoCompactOff {
127	144	c.AutoCompact = ""
128	145	}
	146	+ // Anything other than the one word means the marker was not written by a
	147	+ // wizard that finished, so it does not count as one.
	148	+ if c.Setup != SetupDone {
	149	+ c.Setup = ""
	150	+ }
129	151	return c
130	152	}
131	153

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

@@ -153,6 +153,56 @@ func TestFlagsOverrideTheConfig(t *testing.T) {
153	153	}
154	154	}
155	155
	156	+ // The marker is what suppresses the wizard, so it has to survive the file
	157	+ // unchanged — and a config without it has to keep reading as unfinished.
	158	+ func TestSetupMarkerRoundTrips(t *testing.T) {
	159	+ isolate(t)
	160	+
	161	+ if (Config{Model: "claude-opus-5"}).Done() {
	162	+ t.Error("a config with no marker reported the setup as done")
	163	+ }
	164	+
	165	+ want := Config{Model: "claude-opus-5", Theme: "mono", Setup: SetupDone}
	166	+ if err := Save(want); err != nil {
	167	+ t.Fatal(err)
	168	+ }
	169	+ got, found, err := Load()
	170	+ if err != nil \|\| !found {
	171	+ t.Fatalf("Load(found=%v): %v", found, err)
	172	+ }
	173	+ if !got.Done() {
	174	+ t.Errorf("the setup marker did not survive the round trip: %+v", got)
	175	+ }
	176	+ }
	177	+
	178	+ // A config that exists but was never finished is the case the marker exists
	179	+ // for: the file is there, and the wizard still has questions to ask.
	180	+ func TestAnUnfinishedConfigIsNotDone(t *testing.T) {
	181	+ path := isolate(t)
	182	+ if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
	183	+ t.Fatal(err)
	184	+ }
	185	+ // A marker of the wrong type — "setup": true, the obvious wrong guess for
	186	+ // someone editing by hand — is not in this list: that is a parse failure
	187	+ // for the whole file, which Load already reports rather than papering over.
	188	+ for _, body := range []string{
	189	+ `{"version":1,"theme":"mint"}`,
	190	+ `{"version":1,"theme":"mint","setup":"maybe"}`,
	191	+ `{"version":1,"theme":"mint","setup":""}`,
	192	+ } {
	193	+ if err := os.WriteFile(path, []byte(body), 0o644); err != nil {
	194	+ t.Fatal(err)
	195	+ }
	196	+ cfg, _, _ := Load()
	197	+ if cfg.Done() {
	198	+ t.Errorf("%s reported the setup as done", body)
	199	+ }
	200	+ if cfg.Theme != "mint" {
	201	+ t.Errorf("%s lost the settings it did have: %+v", body, cfg)
	202	+ }
	203	+ }
	204	+ }
	205	+
156	206	func TestAutoCompactRoundTripsAndSanitizes(t *testing.T) {
157	207	isolate(t)
158	208	for _, v := range []string{AutoCompactOn, AutoCompactOff} {

+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: "compact", desc: "fold the conversation into a summary now"},
30	31	{name: "clear", desc: "empty the transcript"},

+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
@@ -540,6 +554,9 @@ func (m *model) onKey(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
540	554	if m.phase == phaseModel {
541	555	return m.onModelKey(msg)
542	556	}
	557	+ if m.phase == phaseSettings {
	558	+ return m.onSettingsKey(msg)
	559	+ }
543	560
544	561	// An open menu owns the keys that drive it — including enter and esc,
545	562	// which mean something else the rest of the time.
@@ -719,6 +736,9 @@ func (m *model) submit(line string) (tea.Model, tea.Cmd) {
719	736	}
720	737	return m, m.sync()
721	738
	739	+ case line == "/settings":
	740	+ return m, m.openSettings()
	741	+
722	742	case line == "/setup":
723	743	if m.phase == phaseRunning {
724	744	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 ""
++ }

+375−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)
++ 			}
++ 		}
++ 	}
++ }
++ // The panel shows four rows but writes the whole config, so a setting it has
++ // no row for has to come through untouched — otherwise cycling the theme would
++ // quietly turn auto-compaction back on.
++ func TestSettingsKeepsSettingsItHasNoRowFor(t *testing.T) {
++ 	m, saved := newSettingsModel(t, config.Config{
++ 		Theme:       "ember",
++ 		Setup:       config.SetupDone,
++ 		AutoCompact: config.AutoCompactOff,
++ 	})
++ 	openSettingsPanel(t, m)
++ 	m.setIdx = setThemeRow
++ 	m.Update(key("right"))
++ 	m.Update(key("esc"))
++ 	if *saved == nil {
++ 		t.Fatal("changing the theme saved nothing")
++ 	}
++ 	if (*saved).AutoCompact != config.AutoCompactOff {
++ 		t.Errorf("auto_compact = %q, want it carried through untouched", (*saved).AutoCompact)
++ 	}
++ }

+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