johannSoCodeyPublic

tui: the agents sidebar

ctrl+b opens a pane on the right listing every subagent: status glyph, id and
preset, with the model, elapsed, turns and cost under it. Enter reads one
agent's own thread in the main pane — the only place its turns are visible at
all — and p and k pause and stop it.

Open and focused are separate. The pane answers every key while it has focus,
which is what lets k be a kill rather than a letter, so clicking the prompt
puts the keyboard back without closing what you were watching. Which pane is
live is visible in the heading, the prompt frame and the pane's own footer.

Reports arrive by themselves: a finished agent's report goes into the
conversation and the agent is set going on it, held back only while a turn is
running, an approval is up, a local command is running, or the prompt has text
in it — a turn starting under your fingers would eat what you were typing.

Two things the supervisor forced. Acting on an agent happens in a command
rather than in Update, because the supervisor answers by sending this program a
message and the channel that carries it is read by the update loop itself.
And an approval no longer implies a running turn: a subagent can ask while you
are idle, and answering has to put the session back where it found it.

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

Browse Files

Jjonicommitted 4 weeks ago1 parent 3869bc2commit85bbaf0

Showing 13 changed files with 2376 additions and 52 deletions.

+195−0internal/tui/agents_live_test.goaddedView File

++ package tui
++ import (
++ 	"bytes"
++ 	"context"
++ 	"encoding/json"
++ 	"io"
++ 	"net/http"
++ 	"net/http/httptest"
++ 	"strings"
++ 	"sync"
++ 	"testing"
++ 	"time"
++ 	"github.com/charmbracelet/bubbles/spinner"
++ 	tea "github.com/charmbracelet/bubbletea"
++ 	"harness/internal/agent"
++ 	"harness/internal/approval"
++ 	"harness/internal/llm"
++ 	"harness/internal/metrics"
++ 	"harness/internal/subagent"
++ 	"harness/internal/tools"
++ )
++ // scriptedAPI answers the main agent and its children differently, so one
++ // server can play both halves of a spawn.
++ func scriptedAPI(t *testing.T) *httptest.Server {
++ 	t.Helper()
++ 	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
++ 		body, _ := io.ReadAll(r.Body)
++ 		var req llm.Request
++ 		json.Unmarshal(body, &req)
++ 		var system string
++ 		for _, b := range req.System {
++ 			system += b.Text
++ 		}
++ 		var conversation string
++ 		for _, m := range req.Messages {
++ 			for _, b := range m.Content {
++ 				conversation += b.Text + b.Content
++ 			}
++ 		}
++ 		switch {
++ 		case strings.Contains(system, "You are a subagent"):
++ 			io.WriteString(w, liveMsg("end_turn", `{"type":"text","text":"found it in internal/approval/policy.go:70"}`))
++ 		case strings.Contains(conversation, "[subagent a1"):
++ 			io.WriteString(w, liveMsg("end_turn", `{"type":"text","text":"thanks — that is the line I needed"}`))
++ 		case strings.Contains(conversation, "started a1"):
++ 			io.WriteString(w, liveMsg("end_turn", `{"type":"text","text":"an agent is on it"}`))
++ 		default:
++ 			io.WriteString(w, liveMsg("tool_use", `{"type":"tool_use","id":"tu_1","name":"spawn_agent",`+
++ 				`"input":{"preset":"explore","task":"find where the approval policy is consulted"}}`))
++ 		}
++ 	}))
++ 	t.Cleanup(srv.Close)
++ 	return srv
++ }
++ func liveMsg(stop string, blocks ...string) string {
++ 	return `{"id":"msg","type":"message","role":"assistant","model":"m","content":[` +
++ 		strings.Join(blocks, ",") + `],"stop_reason":"` + stop + `",` +
++ 		`"usage":{"input_tokens":100,"output_tokens":20}}`
++ }
++ // A whole spawn, end to end: the model asks for an agent, the supervisor runs
++ // it, the sidebar fills in, the agent's own thread is readable, and its report
++ // comes back into the conversation without anybody typing.
++ func TestSpawningFillsTheSidebarAndTheReportComesBack(t *testing.T) {
++ 	srv := scriptedAPI(t)
++ 	root := t.TempDir()
++ 	log := metrics.NewWriter(&bytes.Buffer{}, "test")
++ 	client := llm.New(llm.WithBaseURL(srv.URL), llm.WithAPIKey("k"))
++ 	policy := approval.New(nil)
++ 	policy.YOLO = true // approvals have their own tests; this one is about the wiring
++ 	newTools := func(state *agent.State, log *metrics.Logger) *tools.Registry {
++ 		return tools.NewRegistry(log).Register(tools.NewRead(root, state))
++ 	}
++ 	sup := subagent.New(context.Background(), subagent.Options{
++ 		Client: client, Log: log, Policy: policy, Tools: newTools,
++ 	})
++ 	t.Cleanup(sup.Shutdown)
++ 	state := agent.NewState()
++ 	reg := newTools(state, log)
++ 	reg.Register(sup.Tools()...)
++ 	a := agent.New(client, reg, state, log, agent.Options{})
++ 	a.Approve = policy
++ 	m := newModel(context.Background(), Options{
++ 		Agent: a, Client: client, Policy: policy, Agents: sup, Root: root,
++ 		SessionDir: t.TempDir(), SessionID: "test",
++ 	})
++ 	m.Update(tea.WindowSizeMsg{Width: 100, Height: 30})
++ 	// Everything the supervisor and the agent report arrives here, and is
++ 	// pumped into the model from this goroutine — which is exactly what
++ 	// Bubble Tea's Send does in the real program.
++ 	msgs := make(chan tea.Msg, 256)
++ 	sup.Subscribe(
++ 		func(ev subagent.Event) { msgs <- evSub{ev: ev} },
++ 		func() { msgs <- evAgents{} },
++ 	)
++ 	a.Observe = func(ev agent.Event) {
++ 		if ev.Kind == agent.EventToolResult {
++ 			msgs <- evToolResult{tool: ev.Tool, result: ev.Result}
++ 		}
++ 	}
++ 	// Send a prompt the way the prompt box does, and run the commands it
++ 	// returns off the update loop, as the program's scheduler would.
++ 	d := &driver{msgs: msgs}
++ 	// Everything the model started has to finish before the test's temporary
++ 	// directories go away: a turn saves its session as it ends.
++ 	defer d.wg.Wait()
++ 	_, cmd := m.submit("find where the approval policy is consulted")
++ 	d.run(cmd)
++ 	deadline := time.After(10 * time.Second)
++ 	var sawReport bool
++ 	for !sawReport {
++ 		select {
++ 		case msg := <-msgs:
++ 			_, next := m.Update(msg)
++ 			d.run(next)
++ 			sawReport = strings.Contains(historyText(a), "[subagent a1")
++ 		case <-deadline:
++ 			t.Fatalf("the report never came back. transcript:\n%s", m.tr.render())
++ 		}
++ 	}
++ 	// The sidebar knows about it, and the thread is readable.
++ 	if len(m.bar.rows) != 1 || m.bar.rows[0].ID != "a1" {
++ 		t.Fatalf("sidebar rows = %+v", m.bar.rows)
++ 	}
++ 	m.Update(key("ctrl+b"))
++ 	m.Update(key("enter"))
++ 	if view := m.View(); !strings.Contains(view, "internal/approval/policy.go:70") {
++ 		t.Errorf("a1's own thread is not readable:\n%s", view)
++ 	}
++ 	// And the main transcript said so in one line rather than repeating the
++ 	// whole report.
++ 	if !strings.Contains(m.tr.render(), "a1 (explore) finished") {
++ 		t.Errorf("the main transcript never noticed a1 finishing:\n%s", m.tr.render())
++ 	}
++ }
++ // driver runs Bubble Tea commands off the update loop, the way the program's
++ // own scheduler does, and keeps count of them so a test can wait for the work
++ // it started. A batch is a list of commands rather than a message, so it is
++ // unpacked here exactly as the real scheduler unpacks it.
++ //
++ // Spinner ticks are dropped: feeding one back produces another for ever, and
++ // the animation is not what any of this is testing.
++ type driver struct {
++ 	wg   sync.WaitGroup
++ 	msgs chan tea.Msg
++ }
++ func (d *driver) run(cmd tea.Cmd) {
++ 	if cmd == nil {
++ 		return
++ 	}
++ 	d.wg.Add(1)
++ 	go func() {
++ 		defer d.wg.Done()
++ 		switch msg := cmd().(type) {
++ 		case nil, tea.QuitMsg, spinner.TickMsg:
++ 		case tea.BatchMsg:
++ 			for _, c := range msg {
++ 				d.run(c)
++ 			}
++ 		default:
++ 			select {
++ 			case d.msgs <- msg:
++ 			default: // nobody is reading any more; the test is done
++ 			}
++ 		}
++ 	}()
++ }
++ func historyText(a *agent.Agent) string {
++ 	var s string
++ 	for _, m := range a.State().History() {
++ 		for _, b := range m.Content {
++ 			s += b.Text
++ 		}
++ 	}
++ 	return s
++ }

+23−0internal/tui/bridge.goView File

@@ -8,6 +8,7 @@ import (
8	8	"harness/internal/agent"
9	9	"harness/internal/approval"
10	10	"harness/internal/llm"
	11	+ "harness/internal/subagent"
11	12	)
12	13
13	14	// The agent loop runs on its own goroutine and must not know a UI exists. It
@@ -38,6 +39,16 @@ type (
38	39	evUsage struct{ usage llm.Usage }
39	40	evCompact struct{}
40	41
	42	+ // evSub is one subagent's event, tagged with the agent it came from.
	43	+ evSub struct{ ev subagent.Event }
	44	+ // agentActed comes back from a pause, resume or kill asked for in the
	45	+ // sidebar, carrying whatever the supervisor refused with.
	46	+ agentActed struct{ err error }
	47	+ // evAgents says a subagent's status moved or one finished. It carries
	48	+ // nothing: the model reads the supervisor, which is the one copy of the
	49	+ // truth, rather than a snapshot that was true when it was sent.
	50	+ evAgents struct{}
	51	+
41	52	// approvalMsg asks the user to decide. reply is buffered, so answering
42	53	// never blocks the UI even if the agent's context was cancelled first.
43	54	approvalMsg struct {
@@ -77,6 +88,18 @@ func (b *bridge) Observe(ev agent.Event) {
77	88	}
78	89	}
79	90
	91	+ // Subagent is the subagent.Options.Observe callback, called from a child's
	92	+ // own goroutine.
	93	+ func (b *bridge) Subagent(ev subagent.Event) { b.p.Send(evSub{ev: ev}) }
	94	+
	95	+ // AgentsChanged is the subagent.Options.Changed callback: something moved,
	96	+ // come and look.
	97	+ //
	98	+ // Send blocks until the update loop reads it, so this must never be reached
	99	+ // from inside Update — see controlSelected, which is why agent controls run
	100	+ // as commands.
	101	+ func (b *bridge) AgentsChanged() { b.p.Send(evAgents{}) }
	102	+
80	103	// Prompt implements approval.Prompt. It hands the request to the UI and waits.
81	104	//
82	105	// The context is honoured while waiting, so ctrl-c during an approval prompt

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

@@ -26,6 +26,7 @@ var builtins = []command{
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	28	{name: "setup", desc: "the full-screen wizard for the saved defaults"},
	29	+ {name: "mouse", desc: "turn mouse reporting off, for selecting text with the terminal"},
29	30	{name: "clear", desc: "empty the transcript"},
30	31	{name: "allowed", desc: "what is permanently allowed this session"},
31	32	{name: "exit", desc: "leave the harness"},
@@ -79,6 +80,7 @@ func (m *model) helpText() string {
79	80	fmt.Fprintf(&b, "\n %-18s %s", "/<skill>", plural(n, "discovered skill")+" — /skills lists them")
80	81	}
81	82	b.WriteString("\nkeys: enter send · ctrl+j newline · shift+tab cycle approval mode" +
	83	+ "\n ctrl+b the agents sidebar — ↑↓ move · enter read one · p pause · k kill" +
82	84	"\n ! runs a shell command · $ runs python — both on an empty prompt" +
83	85	"\n what they print goes to the agent too, so you can then say \"fix that\"" +
84	86	"\n / opens the command menu · ↑↓ move · tab or enter complete · esc dismiss" +

+3−3internal/tui/complete.goView File

@@ -142,7 +142,7 @@ func (m *model) menuView() string {
142	142	for _, c := range m.menu.items[start:end] {
143	143	width = maxInt(width, lipgloss.Width("/"+c.name))
144	144	}
145		- width = minInt(width, maxInt(12, m.width/3))
	145	+ width = minInt(width, maxInt(12, m.mainWidth()/3))
146	146
147	147	var b strings.Builder
148	148	for i := start; i < end; i++ {
@@ -158,10 +158,10 @@ func (m *model) menuView() string {
158	158	} else {
159	159	line = " " + styDim.Render(name) + " " + styFaint.Render(desc)
160	160	}
161		- b.WriteString(truncateStyled(" "+line, maxInt(1, m.width)) + "\n")
	161	+ b.WriteString(truncateStyled(" "+line, maxInt(1, m.mainWidth())) + "\n")
162	162	}
163	163	if n := len(m.menu.items) - (end - start); n > 0 {
164		- b.WriteString(truncateStyled(" "+styFaint.Render(fmt.Sprintf("… +%d more", n)), maxInt(1, m.width)) + "\n")
	164	+ b.WriteString(truncateStyled(" "+styFaint.Render(fmt.Sprintf("… +%d more", n)), maxInt(1, m.mainWidth())) + "\n")
165	165	}
166	166	return strings.TrimRight(b.String(), "\n")
167	167	}

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

@@ -101,7 +101,7 @@ func (m *model) applyEffort(level string) {
101	101	// ─────────────────────────────▲───────────────────────────────────
102	102	// low medium high xhigh max
103	103	func (m *model) effortView() string {
104		- width := maxInt(1, m.width)
	104	+ width := maxInt(1, m.mainWidth())
105	105
106	106	starts := effortSlots(width - 1)
107	107	if starts == nil {

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

@@ -19,6 +19,7 @@ import (
19	19	"harness/internal/config"
20	20	"harness/internal/llm"
21	21	"harness/internal/skills"
	22	+ "harness/internal/subagent"
22	23	)
23	24
24	25	// Options wires the TUI to an already-built agent. The TUI owns no policy of
@@ -46,6 +47,9 @@ type Options struct {
46	47	// Skills are the instruction sets discovered at startup, used to resolve
47	48	// /<slug> and to answer /skills.
48	49	Skills []skills.Skill
	50	+ // Agents is the subagent supervisor, or nil where there is none: the
	51	+ // sidebar simply never opens, and no spawn tool was registered either.
	52	+ Agents Agents
49	53
50	54	// Config is what was loaded from disk, and FirstRun says there was nothing
51	55	// to load — which is what opens the setup wizard unprompted.
@@ -133,9 +137,31 @@ type model struct {
133	137	modelIdx int
134	138	modelsLoading bool
135	139
	140	+ // The agents sidebar: whether it is open, what it last drew, and which
	141	+ // agent's thread has taken over the main pane.
	142	+ bar sidebar
	143	+ viewing string
	144	+ // subTr is one scrollback per subagent, so a thread you open reads the
	145	+ // way your own does.
	146	+ subTr map[string]*transcript
	147	+ // pendingReports are finished agents whose reports have not gone up yet,
	148	+ // because a turn was running or the prompt had text in it.
	149	+ pendingReports []subagent.Info
	150	+ // mouseOn tracks whether mouse reporting is enabled, because turning it
	151	+ // on takes the terminal's own text selection away.
	152	+ mouseOn bool
	153	+ // pill is where the agents pill was last drawn, so a click on it can be
	154	+ // recognised.
	155	+ pill rowHit
	156	+
136	157	// pending approvals. The agent blocks on one at a time, but a queue costs
137		- // nothing and means a second request can never be dropped.
	158	+ // nothing and means a second request can never be dropped — and with
	159	+ // subagents there can genuinely be several, from different agents.
138	160	pending []approvalMsg
	161	+ // beforeApproval is what the session was doing when the box went up. An
	162	+ // approval no longer implies a turn in flight: a subagent can ask while
	163	+ // you are idle, and answering has to put you back where you were.
	164	+ beforeApproval phase
139	165
140	166	// ctx plumbing for the running turn.
141	167	parent context.Context
@@ -219,7 +245,10 @@ func newModel(ctx context.Context, opts Options) *model {
219	245	// Run starts the program and blocks until the user exits.
220	246	func Run(ctx context.Context, opts Options) error {
221	247	m := newModel(ctx, opts)
222		- p := tea.NewProgram(m, tea.WithAltScreen(), tea.WithContext(ctx))
	248	+ // Mouse reporting buys the clickable agents pill and a scroll wheel, and
	249	+ // costs the terminal's own text selection. /mouse gives it back.
	250	+ m.mouseOn = true
	251	+ p := tea.NewProgram(m, tea.WithAltScreen(), tea.WithContext(ctx), tea.WithMouseCellMotion())
223	252
224	253	// The bridge can only learn the program after it exists; the agent does
225	254	// not touch it until the first turn starts, which is after Run.
@@ -228,6 +257,9 @@ func Run(ctx context.Context, opts Options) error {
228	257	if opts.Policy != nil {
229	258	opts.Policy.Prompt = m.bridge.Prompt
230	259	}
	260	+ if opts.Agents != nil {
	261	+ opts.Agents.Subscribe(m.bridge.Subagent, m.bridge.AgentsChanged)
	262	+ }
231	263
232	264	final, err := p.Run()
233	265	if err != nil && !errors.Is(err, tea.ErrProgramKilled) && !errors.Is(err, context.Canceled) {
@@ -310,6 +342,26 @@ func (m *model) closeWizard() tea.Cmd {
310	342	return tea.Batch(m.sync(), textarea.Blink)
311	343	}
312	344
	345	+ // runContinue drives a turn on the conversation as it stands — the report a
	346	+ // subagent just filed is already in it. Everything else about the turn is the
	347	+ // same, including saving the session when it ends.
	348	+ func (m *model) runContinue() tea.Cmd {
	349	+ ctx, cancel := context.WithCancel(m.parent)
	350	+ m.cancel = cancel
	351	+
	352	+ a := m.opts.Agent
	353	+ return func() tea.Msg {
	354	+ _, err := a.Continue(ctx)
	355	+ cancel()
	356	+
	357	+ if saveErr := a.Save(m.opts.SessionDir, m.opts.SessionID, m.opts.Root, m.opts.Client.Model()); saveErr != nil && err == nil {
	358	+ err = fmt.Errorf("saving session: %w", saveErr)
	359	+ }
	360	+ u, turns := a.State().Usage()
	361	+ return turnDone{err: err, usage: u, turns: turns}
	362	+ }
	363	+ }
	364	+
313	365	// runTurn drives one prompt on its own goroutine. Events reach the UI through
314	366	// the bridge while this runs; the command's return value ends the turn.
315	367	func (m *model) runTurn(prompt string) tea.Cmd {
@@ -397,10 +449,25 @@ func (m *model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
397	449	return m, m.sync()
398	450
399	451	case approvalMsg:
	452	+ if m.phase != phaseApproving {
	453	+ m.beforeApproval = m.phase
	454	+ }
400	455	m.pending = append(m.pending, msg)
401	456	m.phase = phaseApproving
402	457	return m, m.sync()
403	458
	459	+ case evSub:
	460	+ return m, m.onSubEvent(msg.ev)
	461	+
	462	+ case evAgents:
	463	+ return m, m.onAgentsChanged()
	464	+
	465	+ case agentActed:
	466	+ return m, m.onAgentActed(msg)
	467	+
	468	+ case tea.MouseMsg:
	469	+ return m, m.onMouse(msg)
	470	+
404	471	case turnDone:
405	472	return m, m.finishTurn(msg)
406	473
@@ -413,21 +480,64 @@ func (m *model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
413	480
414	481	func (m *model) resize(w, h int) tea.Cmd {
415	482	m.width, m.height = w, h
416		- m.tr.setWidth(w)
417		- m.input.SetWidth(m.innerWidth())
418		-
419	483	if !m.ready {
420		- m.vp = viewport.New(w, maxInt(1, h-8))
	484	+ m.vp = viewport.New(m.mainWidth(), maxInt(1, h-8))
421	485	m.ready = true
422		- } else {
423		- m.vp.Width = w
424	486	}
425		- m.refreshSplash()
426		- m.vp.SetContent(m.tr.render())
	487	+ m.relayout()
427	488	m.vp.GotoBottom()
428	489	return nil
429	490	}
430	491
	492	+ // relayout re-flows everything that is sized against the main column, which
	493	+ // is narrower whenever the sidebar is open.
	494	+ func (m *model) relayout() tea.Cmd {
	495	+ if !m.ready {
	496	+ return nil
	497	+ }
	498	+ w := m.mainWidth()
	499	+ m.tr.setWidth(w)
	500	+ for _, t := range m.subTr {
	501	+ t.setWidth(w)
	502	+ }
	503	+ m.input.SetWidth(m.innerWidth())
	504	+ m.vp.Width = w
	505	+ m.refreshSplash()
	506	+ return m.sync()
	507	+ }
	508	+
	509	+ // mainWidth is what is left for the transcript and the prompt.
	510	+ func (m *model) mainWidth() int {
	511	+ if m.bar.visible() && !m.fullScreenSidebar() {
	512	+ return maxInt(20, m.width-sidebarWidth)
	513	+ }
	514	+ return m.width
	515	+ }
	516	+
	517	+ // sidebarTakesOver reports whether the terminal is too narrow to show both.
	518	+ // Squeezing a transcript into thirty columns shows neither.
	519	+ func (m *model) fullScreenSidebar() bool {
	520	+ return m.bar.visible() && m.width-sidebarWidth < sidebarMinMain
	521	+ }
	522	+
	523	+ func (m *model) sidebarWidth() int {
	524	+ if m.fullScreenSidebar() {
	525	+ return m.width
	526	+ }
	527	+ return sidebarWidth
	528	+ }
	529	+
	530	+ // activeTranscript is what the main pane is showing: your own conversation, or
	531	+ // the thread of the agent you opened.
	532	+ func (m model) activeTranscript() transcript {
	533	+ if m.viewing != "" {
	534	+ if t, ok := m.subTr[m.viewing]; ok {
	535	+ return t
	536	+ }
	537	+ }
	538	+ return m.tr
	539	+ }
	540	+
431	541	// refreshSplash re-renders the welcome block. It is the one entry that owns
432	542	// its own lines — laid out for a width, and naming the model and the endpoint
433	543	// — so when any of those change it is rebuilt rather than wrapped or left to
@@ -436,7 +546,7 @@ func (m *model) refreshSplash() {
436	546	if len(m.tr.entries) == 0 \|\| m.tr.entries[0].kind != entryRaw {
437	547	return
438	548	}
439		- width := m.width
	549	+ width := m.mainWidth()
440	550	if width <= 0 {
441	551	width = 80
442	552	}
@@ -451,7 +561,7 @@ func (m *model) sync() tea.Cmd {
451	561	return nil
452	562	}
453	563	atBottom := m.vp.AtBottom()
454		- m.vp.SetContent(m.tr.render())
	564	+ m.vp.SetContent(m.activeTranscript().render())
455	565	if atBottom {
456	566	m.vp.GotoBottom()
457	567	}
@@ -465,11 +575,22 @@ func (m *model) finishTurn(msg turnDone) tea.Cmd {
465	575	m.addCost(subUsage(msg.usage, m.priced))
466	576	m.tr.closeOpen()
467	577
468		- // Any approval still outstanding belongs to a turn that no longer exists.
	578	+ // An approval this turn raised belongs to a turn that no longer exists, so
	579	+ // it is denied. A subagent's does not: that agent is still running, and
	580	+ // the decision is still the user's to make.
	581	+ var kept []approvalMsg
469	582	for _, p := range m.pending {
470		- p.reply <- approval.Deny
	583	+ if p.req.Agent == "" {
	584	+ p.reply <- approval.Deny
	585	+ continue
	586	+ }
	587	+ kept = append(kept, p)
	588	+ }
	589	+ m.pending = kept
	590	+ if len(m.pending) > 0 {
	591	+ m.phase = phaseApproving
	592	+ m.beforeApproval = phaseIdle
471	593	}
472		- m.pending = nil
473	594
474	595	switch {
475	596	case msg.err == nil:
@@ -478,8 +599,11 @@ func (m *model) finishTurn(msg turnDone) tea.Cmd {
478	599	default:
479	600	m.tr.addError(msg.err.Error())
480	601	}
481		- m.input.Focus()
482		- return tea.Batch(m.sync(), textarea.Blink)
	602	+ if !m.bar.hasKeys() {
	603	+ m.input.Focus()
	604	+ }
	605	+ // Agents that finished mid-turn have been waiting for this.
	606	+ return tea.Batch(m.sync(), textarea.Blink, m.deliverReports())
483	607	}
484	608
485	609	func (m *model) onKey(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
@@ -493,6 +617,15 @@ func (m *model) onKey(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
493	617	return m.onModelKey(msg)
494	618	}
495	619
	620	+ // The sidebar owns every key while it is open, the way the approval box
	621	+ // does: a pane with a kill key cannot share the keyboard with a prompt.
	622	+ if cmd, took := m.onSidebarKey(msg); took {
	623	+ return m, cmd
	624	+ }
	625	+ if msg.String() == "ctrl+b" && m.opts.Agents != nil {
	626	+ return m, m.toggleSidebar()
	627	+ }
	628	+
496	629	// An open menu owns the keys that drive it — including enter and esc,
497	630	// which mean something else the rest of the time.
498	631	if m.menuOpen() {
@@ -572,7 +705,8 @@ func (m *model) onKey(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
572	705	m.input, cmd = m.input.Update(msg)
573	706	m.growInput()
574	707	m.refreshMenu()
575		- return m, cmd
	708	+ // Emptying the prompt is what a report held back for it was waiting on.
	709	+ return m, tea.Batch(cmd, m.deliverReports())
576	710	}
577	711
578	712	func (m *model) interrupt() tea.Cmd {
@@ -630,6 +764,9 @@ func (m *model) submit(line string) (tea.Model, tea.Cmd) {
630	764	case line == "/effort" \|\| strings.HasPrefix(line, "/effort "):
631	765	return m, m.setEffort(strings.TrimSpace(strings.TrimPrefix(line, "/effort")))
632	766
	767	+ case line == "/mouse":
	768	+ return m, m.toggleMouse()
	769	+
633	770	case line == "/clear":
634	771	m.tr.clear()
635	772	return m, m.sync()
@@ -668,6 +805,11 @@ func (m *model) submit(line string) (tea.Model, tea.Cmd) {
668	805	return m, m.sync()
669	806	}
670	807
	808	+ // Anything a subagent reported while you were typing goes up as its own
	809	+ // message, ahead of yours: the model should not have to work out which
	810	+ // half of one message was whose.
	811	+ m.flushReportsAhead()
	812	+
671	813	m.tr.addUser(line)
672	814	m.phase = phaseRunning
673	815	m.turn = 0
@@ -753,18 +895,23 @@ func (m *model) choices(req approval.Request) []choice {
753	895
754	896	func (m *model) onApprovalKey(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
755	897	if len(m.pending) == 0 {
756		- m.phase = phaseRunning
	898	+ m.phase = m.beforeApproval
757	899	return m, nil
758	900	}
759	901	req := m.pending[0]
760	902	key := msg.String()
761	903
762		- // ctrl-c mid-prompt denies the call and cancels the turn.
	904	+ // ctrl-c mid-prompt denies the call and cancels the turn it belonged to.
	905	+ // With nothing of yours running there is no turn to cancel — the denial
	906	+ // is the whole of it.
763	907	if key == "ctrl+c" {
764	908	req.reply <- approval.Deny
765	909	m.pending = m.pending[1:]
766		- m.phase = phaseRunning
767		- return m, tea.Batch(m.interrupt(), m.sync())
	910	+ m.phase = m.phaseAfterApproval()
	911	+ if m.phase == phaseRunning {
	912	+ return m, tea.Batch(m.interrupt(), m.sync())
	913	+ }
	914	+ return m, m.sync()
768	915	}
769	916
770	917	// "always this exact one" is not offered for an opaque command, and
@@ -782,7 +929,7 @@ func (m *model) onApprovalKey(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
782	929	req.reply <- c.dec
783	930	m.pending = m.pending[1:]
784	931	if len(m.pending) == 0 {
785		- m.phase = phaseRunning
	932	+ m.phase = m.beforeApproval
786	933	}
787	934	// The decision belongs to the call it gated, not to whatever the
788	935	// transcript happens to end with once the result lands.
@@ -792,6 +939,15 @@ func (m *model) onApprovalKey(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
792	939	return m, nil
793	940	}
794	941
	942	+ // phaseAfterApproval is where the session goes once the queue empties: back to
	943	+ // whatever it was doing, or straight on to the next request if one is waiting.
	944	+ func (m *model) phaseAfterApproval() phase {
	945	+ if len(m.pending) > 0 {
	946	+ return phaseApproving
	947	+ }
	948	+ return m.beforeApproval
	949	+ }
	950	+
795	951	func matches(keys []string, key string) bool {
796	952	for _, k := range keys {
797	953	if k == key {
@@ -814,18 +970,36 @@ func (m *model) View() string {
814	970	return m.wiz.View()
815	971	}
816	972
	973	+ // Too narrow for both: the pane takes the screen rather than leaving two
	974	+ // unreadable columns. The status line goes with the transcript, so the
	975	+ // pill it carries is not on screen and its click target is forgotten
	976	+ // rather than left pointing at whatever is drawn there now.
	977	+ if m.fullScreenSidebar() {
	978	+ m.pill = rowHit{}
	979	+ return m.sidebarView(m.height)
	980	+ }
	981	+
817	982	// The bottom chrome changes height — the prompt box grows, the approval
818	983	// box is taller than either — so the viewport is sized against what was
819	984	// actually rendered rather than against an assumed number of rows.
820	985	bottom := m.bottom()
821		- if h := maxInt(1, m.height-lipgloss.Height(bottom)); h != m.vp.Height {
	986	+ top := ""
	987	+ if m.viewing != "" {
	988	+ top = m.agentHeader(m.mainWidth()) + "\n"
	989	+ }
	990	+ if h := maxInt(1, m.height-lipgloss.Height(bottom)-strings.Count(top, "\n")); h != m.vp.Height {
822	991	atBottom := m.vp.AtBottom()
823	992	m.vp.Height = h
824	993	if atBottom {
825	994	m.vp.GotoBottom()
826	995	}
827	996	}
828		- return m.vp.View() + "\n" + bottom
	997	+
	998	+ main := top + m.vp.View() + "\n" + bottom
	999	+ if !m.bar.visible() {
	1000	+ return main
	1001	+ }
	1002	+ return lipgloss.JoinHorizontal(lipgloss.Top, main, m.sidebarView(m.height))
829	1003	}
830	1004
831	1005	func (m *model) bottom() string {
@@ -855,7 +1029,7 @@ func (m *model) bottom() string {
855	1029	// changes that is the one worth naming beside it.
856	1030	func (m *model) activity() string {
857	1031	if m.running != nil {
858		- return spread(m.localActivity(), "", m.width)
	1032	+ return spread(m.localActivity(), "", m.mainWidth())
859	1033	}
860	1034
861	1035	var left string
@@ -879,21 +1053,29 @@ func (m *model) activity() string {
879	1053
880	1054	right := ""
881	1055	if m.opts.Effort != "" {
882		- right = styDim.Render("● "+m.opts.Effort) + styFaint.Render(" · /effort")
	1056	+ // The pill is a claim about the next request. On a model that does
	1057	+ // not take this level the harness leaves it out rather than earning a
	1058	+ // 400, so the pill says which model is ignoring it instead of
	1059	+ // reporting a setting that is not in force.
	1060	+ note := " · /effort"
	1061	+ if !llm.SupportsEffort(m.opts.Client.Model(), m.opts.Effort) {
	1062	+ note = " · not on " + shortModel(m.opts.Client.Model())
	1063	+ }
	1064	+ right = styDim.Render("● "+m.opts.Effort) + styFaint.Render(note)
883	1065	}
884		- return spread(left, right, m.width)
	1066	+ return spread(left, right, m.mainWidth())
885	1067	}
886	1068
887	1069	func (m *model) innerWidth() int { return maxInt(8, m.boxWidth()-4) }
888	1070
889	1071	// boxWidth keeps the prompt frame usable on a narrow terminal rather than
890	1072	// letting it collapse into a border with no room inside it.
891		- func (m *model) boxWidth() int { return maxInt(14, m.width) }
	1073	+ func (m *model) boxWidth() int { return maxInt(14, m.mainWidth()) }
892	1074
893	1075	func (m *model) inputBox() string {
894	1076	style := styBoxFocus
895	1077	switch {
896		- case m.phase == phaseRunning:
	1078	+ case m.phase == phaseRunning, m.bar.hasKeys():
897	1079	style = styBoxBlur
898	1080	case m.local != localOff:
899	1081	// The frame is the always-present chrome, so it is where a mode that
@@ -917,6 +1099,10 @@ func (m *model) status() string {
917	1099	parts = append(parts, pill)
918	1100	}
919	1101
	1102	+ if pill, ok := m.agentsPill(); ok {
	1103	+ parts = append(parts, pill)
	1104	+ }
	1105	+
920	1106	// Cache reads are reported separately from fresh input: the gap between
921	1107	// the two is the whole point of the caching this harness measures.
922	1108	u := m.usage
@@ -931,7 +1117,45 @@ func (m *model) status() string {
931	1117	parts = append(parts, styDim.Render(fmt.Sprintf("$%.4f", m.cost)))
932	1118	}
933	1119	}
934		- return truncateStyled(strings.Join(parts, " "), maxInt(1, m.width))
	1120	+ line := strings.Join(parts, " ")
	1121	+ m.recordPill(parts)
	1122	+ return truncateStyled(line, maxInt(1, m.mainWidth()))
	1123	+ }
	1124	+
	1125	+ // agentsPill is the clickable button in the status line: how many agents are
	1126	+ // live, or just the way in when none are.
	1127	+ func (m *model) agentsPill() (string, bool) {
	1128	+ if m.opts.Agents == nil {
	1129	+ return "", false
	1130	+ }
	1131	+ label := "⏵ agents"
	1132	+ style := styPill
	1133	+ if n := m.bar.live; n > 0 {
	1134	+ label = fmt.Sprintf("⏵ %d agents", n)
	1135	+ style = styPill.Foreground(colCoral)
	1136	+ } else if len(m.bar.rows) == 0 {
	1137	+ return "", false
	1138	+ }
	1139	+ return style.Render(label), true
	1140	+ }
	1141	+
	1142	+ // recordPill remembers where the agents pill was drawn, so a click on it can
	1143	+ // be told from a click on the rest of the status line. The status line is the
	1144	+ // second line from the bottom: the mode line is below it.
	1145	+ func (m *model) recordPill(parts []string) {
	1146	+ m.pill = rowHit{}
	1147	+ pill, ok := m.agentsPill()
	1148	+ if !ok {
	1149	+ return
	1150	+ }
	1151	+ var x int
	1152	+ for _, p := range parts {
	1153	+ if p == pill {
	1154	+ break
	1155	+ }
	1156	+ x += lipgloss.Width(p) + 2
	1157	+ }
	1158	+ m.pill = rowHit{y0: m.height - 2, y1: m.height - 2, x0: x, x1: x + lipgloss.Width(pill) - 1}
935	1159	}
936	1160
937	1161	// contextPill is the context gauge: how much the model read last turn against
@@ -968,19 +1192,23 @@ func (m *model) modeLine() string {
968	1192	if m.phase == phaseApproving {
969	1193	return ""
970	1194	}
	1195	+ agents := ""
	1196	+ if m.opts.Agents != nil {
	1197	+ agents = " · ctrl+b agents"
	1198	+ }
971	1199	if m.opts.Policy != nil && m.opts.Policy.YOLO {
972		- return truncateStyled(" "+styWarn.Render("⏵⏵ accept-all on")+styFaint.Render(" (shift+tab to cycle)"), maxInt(1, m.width))
	1200	+ return truncateStyled(" "+styWarn.Render("⏵⏵ accept-all on")+styFaint.Render(" (shift+tab to cycle)"+agents), maxInt(1, m.mainWidth()))
973	1201	}
974		- return truncateStyled(" "+styFaint.Render("⏵ approvals on (shift+tab to cycle) · /help for commands"), maxInt(1, m.width))
	1202	+ return truncateStyled(" "+styFaint.Render("⏵ approvals on (shift+tab to cycle)"+agents+" · /help"), maxInt(1, m.mainWidth()))
975	1203	}
976	1204
977	1205	func (m *model) approvalView() string {
978	1206	req := m.pending[0].req
979		- width := maxInt(20, m.width-2)
	1207	+ width := maxInt(20, m.mainWidth()-2)
980	1208	inner := width - 4
981	1209
982	1210	var b strings.Builder
983		- b.WriteString(styHeading.Render(req.Tool) + styDim.Render(" wants to "+req.Summary) + "\n")
	1211	+ b.WriteString(m.approvalHead(req) + styDim.Render(" wants to "+req.Summary) + "\n")
984	1212	if req.Detail != "" {
985	1213	b.WriteString("\n")
986	1214	lines := strings.Split(strings.TrimRight(req.Detail, "\n"), "\n")
@@ -1002,6 +1230,21 @@ func (m *model) approvalView() string {
1002	1230	return styModal.Width(width - 2).Render(strings.TrimRight(b.String(), "\n"))
1003	1231	}
1004	1232
	1233	+ // approvalHead is the first thing the box says: the tool, and — when it is not
	1234	+ // the session's own agent asking — which subagent wants it. Four agents can be
	1235	+ // running, and "bash wants to run rm -rf build" is not a question anybody can
	1236	+ // answer without knowing whose it is.
	1237	+ func (m *model) approvalHead(req approval.Request) string {
	1238	+ if req.Agent == "" {
	1239	+ return styHeading.Render(req.Tool)
	1240	+ }
	1241	+ who := req.Agent
	1242	+ if info, ok := m.agentInfo(req.Agent); ok {
	1243	+ who += " (" + info.Preset + ")"
	1244	+ }
	1245	+ return styCoral.Render(who) + styDim.Render(" · ") + styHeading.Render(req.Tool)
	1246	+ }
	1247	+
1005	1248	// spread puts left at the left margin and right at the right, and gives up on
1006	1249	// the right-hand side rather than overflowing when they cannot both fit.
1007	1250	func spread(left, right string, width int) string {
@@ -1024,6 +1267,26 @@ func username() string {
1024	1267
1025	1268	// addCost prices one piece of usage at the model in force and adds it to the
1026	1269	// running total, recording that those tokens have now been paid for.
	1270	+ // addCostAt bills a subagent's usage to the session at that agent's own model:
	1271	+ // a haiku agent spawned from an opus session was not billed at opus rates.
	1272	+ //
	1273	+ // Only the money is pooled. The token counts in the status line stay the main
	1274	+ // conversation's, because the gauge beside them is about the window this
	1275	+ // conversation is filling — a child's tokens went into a different window, and
	1276	+ // the sidebar reports them per agent.
	1277	+ func (m *model) addCostAt(u llm.Usage, model string) {
	1278	+ if u == (llm.Usage{}) {
	1279	+ return
	1280	+ }
	1281	+ if model == "" {
	1282	+ model = m.opts.Client.Model()
	1283	+ }
	1284	+ if c, known := u.Cost(model); known {
	1285	+ m.cost += c
	1286	+ m.costKnown = true
	1287	+ }
	1288	+ }
	1289	+
1027	1290	func (m *model) addCost(u llm.Usage) {
1028	1291	if u == (llm.Usage{}) {
1029	1292	return

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

@@ -141,7 +141,7 @@ func (m *model) applyModel(id string) {
141	141	// modelView is the picker: a heading, where the list came from, and a row per
142	142	// model with what it is called, its id, and what it costs.
143	143	func (m *model) modelView() string {
144		- width := maxInt(1, m.width)
	144	+ width := maxInt(1, m.mainWidth())
145	145	head := " " + styHeading.Render("Select model")
146	146	from := styDim.Render("from " + endpointLabel(m.opts.Client))
147	147

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

@@ -85,6 +85,10 @@ func TestApprovalKeysMapToDecisions(t *testing.T) {
85	85	for _, tc := range cases {
86	86	t.Run(tc.key, func(t *testing.T) {
87	87	m := newTestModel(t)
	88	+ // The session's own agent asks during a turn; answering returns
	89	+ // to it. (A subagent can ask while you are idle — see
	90	+ // TestAnsweringASubagentsApprovalWhileIdleLeavesYouIdle.)
	91	+ m.phase = phaseRunning
88	92	reply := pend(m, approval.Request{Tool: "bash", Rememberable: true})
89	93	if m.phase != phaseApproving {
90	94	t.Fatalf("phase = %v, want phaseApproving", m.phase)
@@ -153,6 +157,10 @@ func TestUnknownKeyDuringApprovalDoesNothing(t *testing.T) {
153	157	// Queued approvals are answered one at a time, in order.
154	158	func TestApprovalsAreQueued(t *testing.T) {
155	159	m := newTestModel(t)
	160	+ // These are the session's own agent asking, which only happens during a
	161	+ // turn. A subagent can ask while you are idle, and then answering puts
	162	+ // you back to idle rather than into a turn that is not running.
	163	+ m.phase = phaseRunning
156	164	first := pend(m, approval.Request{Tool: "bash", Rememberable: true})
157	165	second := pend(m, approval.Request{Tool: "edit_file", Rememberable: true})
158	166
@@ -200,6 +208,7 @@ func TestTurnDoneDeniesOutstandingApprovals(t *testing.T) {
200	208
201	209	func TestCtrlCDuringApprovalDeniesAndInterrupts(t *testing.T) {
202	210	m := newTestModel(t)
	211	+ m.phase = phaseRunning
203	212	cancelled := false
204	213	m.cancel = func() { cancelled = true }
205	214	reply := pend(m, approval.Request{Tool: "bash"})

+727−0internal/tui/sidebar.goaddedView File

++ package tui
++ import (
++ 	"fmt"
++ 	"strings"
++ 	"time"
++ 	"github.com/charmbracelet/bubbles/textarea"
++ 	tea "github.com/charmbracelet/bubbletea"
++ 	"github.com/charmbracelet/lipgloss"
++ 	"harness/internal/agent"
++ 	"harness/internal/llm"
++ 	"harness/internal/subagent"
++ )
++ // Agents is the part of the subagent supervisor the TUI uses: what is running,
++ // what has finished and not been handed over yet, and the three things a
++ // person can do to one. It is an interface so the front end can be driven
++ // without starting real agents.
++ type Agents interface {
++ 	Snapshot() []subagent.Info
++ 	TakeReports() []subagent.Info
++ 	Live() int
++ 	Pause(id string) error
++ 	Resume(id string) error
++ 	Kill(id string) error
++ 	// ClaimReport asks for the right to put one finished agent's report into
++ 	// the conversation, and reports whether this front end got it. It can be
++ 	// refused: agent_wait may have handed the same report to the model while
++ 	// this one sat in the pending queue.
++ 	ClaimReport(id string) bool
++ 	// Subscribe hands the supervisor the two callbacks the front end wants:
++ 	// one per child event, one when anything about the set of agents moves.
++ 	Subscribe(observe func(subagent.Event), changed func())
++ }
++ // sidebarWidth is the pane's width when there is room for it. Thirty columns
++ // fits "claude-haiku-4-5 · 22s · 3 turns" and not much else, which is exactly
++ // what a row has to say.
++ const sidebarWidth = 30
++ // barFrame is what the pane's own chrome costs: one column of rule on the
++ // left and a column of padding either side.
++ const barFrame = 3
++ // sidebarMinMain is how much has to be left for the transcript. Below this the
++ // sidebar takes the whole screen instead of squeezing both into unreadability.
++ const sidebarMinMain = 40
++ // sidebar is the agents pane: whether it is open, whether it has the keyboard,
++ // where the cursor is, and the rows it last drew.
++ //
++ // Open and focused are separate because the pane is worth watching while you
++ // type. It owns every key while it has focus — that is what makes k a kill
++ // rather than a letter — so there has to be a way to put the keyboard back in
++ // the prompt without closing what you were looking at.
++ type sidebar struct {
++ 	open    bool
++ 	focused bool
++ 	cursor  int
++ 	rows    []subagent.Info
++ 	live    int
++ 	// hits records where each row was drawn, so a click can be turned back
++ 	// into an agent. It is rebuilt on every render.
++ 	hits []rowHit
++ }
++ // rowHit is where something clickable was last drawn.
++ type rowHit struct {
++ 	y0, y1 int
++ 	x0, x1 int
++ 	id     string
++ }
++ // hit reports whether a click at (x, y) landed on this region.
++ func (h rowHit) hit(x, y int) bool {
++ 	if y < h.y0 || y > h.y1 {
++ 		return false
++ 	}
++ 	return (h.x0 == 0 && h.x1 == 0) || (x >= h.x0 && x <= h.x1)
++ }
++ // visible reports whether the pane is drawn at all.
++ func (s *sidebar) visible() bool { return s.open }
++ // hasKeys reports whether the pane is the thing keystrokes belong to.
++ func (s *sidebar) hasKeys() bool { return s.open && s.focused }
++ // selected is the agent the cursor is on.
++ func (s *sidebar) selected() (subagent.Info, bool) {
++ 	if s.cursor < 0 || s.cursor >= len(s.rows) {
++ 		return subagent.Info{}, false
++ 	}
++ 	return s.rows[s.cursor], true
++ }
++ func (s *sidebar) move(delta int) {
++ 	if len(s.rows) == 0 {
++ 		return
++ 	}
++ 	s.cursor += delta
++ 	switch {
++ 	case s.cursor < 0:
++ 		s.cursor = 0
++ 	case s.cursor >= len(s.rows):
++ 		s.cursor = len(s.rows) - 1
++ 	}
++ }
++ // selectID puts the cursor on an agent by id.
++ func (s *sidebar) selectID(id string) {
++ 	for i, r := range s.rows {
++ 		if r.ID == id {
++ 			s.cursor = i
++ 			return
++ 		}
++ 	}
++ }
++ // refresh pulls the current rows. The cursor follows the agent it was on
++ // rather than the index, so a row appearing above it does not move the
++ // selection out from under a keystroke.
++ func (m *model) refreshAgents() {
++ 	if m.opts.Agents == nil {
++ 		return
++ 	}
++ 	var on string
++ 	if cur, ok := m.bar.selected(); ok {
++ 		on = cur.ID
++ 	}
++ 	m.bar.rows = m.opts.Agents.Snapshot()
++ 	m.bar.live = m.opts.Agents.Live()
++ 	if on != "" {
++ 		m.bar.selectID(on)
++ 	}
++ 	if m.bar.cursor >= len(m.bar.rows) {
++ 		m.bar.cursor = maxInt(0, len(m.bar.rows)-1)
++ 	}
++ }
++ // toggleSidebar is what ctrl+b does, and it always moves towards the pane:
++ // closed opens it, open-but-unfocused hands it the keyboard, and only a pane
++ // that already has the keyboard is closed. Closing what you are looking at is
++ // never what someone reaching for this key meant.
++ func (m *model) toggleSidebar() tea.Cmd {
++ 	switch {
++ 	case !m.bar.open:
++ 		m.bar.open = true
++ 		m.refreshAgents()
++ 		return m.focusSidebar()
++ 	case !m.bar.focused:
++ 		return m.focusSidebar()
++ 	default:
++ 		m.bar.open, m.bar.focused = false, false
++ 		m.viewing = ""
++ 		m.input.Focus()
++ 		return tea.Batch(m.relayout(), textarea.Blink)
++ 	}
++ }
++ // focusSidebar gives the pane the keyboard. The prompt is blurred, so the
++ // frame says where the next keystroke is going.
++ func (m *model) focusSidebar() tea.Cmd {
++ 	m.bar.focused = true
++ 	m.input.Blur()
++ 	return tea.Batch(m.relayout(), textarea.Blink)
++ }
++ // focusPrompt puts the keyboard back in the prompt, leaving the pane on screen
++ // to watch while you type.
++ func (m *model) focusPrompt() tea.Cmd {
++ 	if !m.bar.focused {
++ 		return nil
++ 	}
++ 	m.bar.focused = false
++ 	m.input.Focus()
++ 	return tea.Batch(m.sync(), textarea.Blink)
++ }
++ // onSidebarKey handles the keys while the pane has them, and reports whether
++ // it took the key.
++ func (m *model) onSidebarKey(msg tea.KeyMsg) (tea.Cmd, bool) {
++ 	if !m.bar.hasKeys() {
++ 		return nil, false
++ 	}
++ 	switch msg.String() {
++ 	case "ctrl+c", "ctrl+d":
++ 		// The keys that stop things are never the pane's. Opening it to watch
++ 		// an agent must not cost you the ability to interrupt your own turn or
++ 		// to leave.
++ 		return nil, false
++ 	case "ctrl+b":
++ 		return m.toggleSidebar(), true
++ 	case "esc":
++ 		// One esc leaves the agent's thread, the next closes the pane: the
++ 		// same key walks back out the way you came in.
++ 		if m.viewing != "" {
++ 			m.viewing = ""
++ 			return m.sync(), true
++ 		}
++ 		return m.toggleSidebar(), true
++ 	case "up":
++ 		m.bar.move(-1)
++ 		return m.followSelection(), true
++ 	case "down":
++ 		m.bar.move(1)
++ 		return m.followSelection(), true
++ 	case "enter":
++ 		if cur, ok := m.bar.selected(); ok {
++ 			m.viewing = cur.ID
++ 			return m.sync(), true
++ 		}
++ 		return nil, true
++ 	case "p":
++ 		return m.controlSelected("p"), true
++ 	case "k":
++ 		return m.controlSelected("k"), true
++ 	}
++ 	// Everything else is swallowed: the pane has the keys while it is open, so
++ 	// a stray letter cannot end up in a prompt nobody is looking at.
++ 	return nil, true
++ }
++ // followSelection keeps the thread on screen in step with the cursor, so
++ // moving down the list while reading walks through the threads.
++ func (m *model) followSelection() tea.Cmd {
++ 	if m.viewing != "" {
++ 		if cur, ok := m.bar.selected(); ok {
++ 			m.viewing = cur.ID
++ 		}
++ 	}
++ 	return m.sync()
++ }
++ // controlSelected applies p (pause or resume, whichever the row is not) or k
++ // (kill) to the agent under the cursor.
++ //
++ // The supervisor is called from the returned command rather than from here,
++ // and that is not a style choice: acting on an agent makes the supervisor
++ // announce the change, which it does by sending this program a message — and
++ // the channel that carries it is read by the update loop we would still be
++ // inside. Calling it here deadlocks the whole program, keyboard included.
++ func (m *model) controlSelected(key string) tea.Cmd {
++ 	cur, ok := m.bar.selected()
++ 	if !ok || m.opts.Agents == nil {
++ 		return nil
++ 	}
++ 	agents, id := m.opts.Agents, cur.ID
++ 	paused := cur.Status == subagent.Paused
++ 	return func() tea.Msg {
++ 		switch {
++ 		case key == "k":
++ 			return agentActed{err: agents.Kill(id)}
++ 		case paused:
++ 			return agentActed{err: agents.Resume(id)}
++ 		default:
++ 			return agentActed{err: agents.Pause(id)}
++ 		}
++ 	}
++ }
++ // onAgentActed reports a refusal — an agent that has already finished, or one
++ // that has not started. The change itself arrives separately, as the
++ // supervisor's own notification.
++ func (m *model) onAgentActed(msg agentActed) tea.Cmd {
++ 	if msg.err == nil {
++ 		return nil
++ 	}
++ 	m.tr.addError(msg.err.Error())
++ 	return m.sync()
++ }
++ // sidebarView draws the pane at the given height.
++ func (m *model) sidebarView(height int) string {
++ 	width := m.sidebarWidth()
++ 	inner := maxInt(8, width-barFrame)
++ 	var b strings.Builder
++ 	// The heading carries the accent only while the pane has the keyboard,
++ 	// which is the same grammar the prompt frame uses.
++ 	head := styDim.Render("Agents")
++ 	if m.bar.focused {
++ 		head = styHeading.Render("Agents")
++ 	}
++ 	count := styFaint.Render("none yet")
++ 	if n := m.bar.live; n > 0 {
++ 		count = styCoral.Render(fmt.Sprintf("%d ⏵", n))
++ 	} else if len(m.bar.rows) > 0 {
++ 		count = styFaint.Render(fmt.Sprintf("%d done", len(m.bar.rows)))
++ 	}
++ 	b.WriteString(spread(head, count, inner) + "\n\n")
++ 	m.bar.hits = nil
++ 	// The pane has no top border, so its first line is the screen's first
++ 	// line: the header and the blank line under it are all that come before
++ 	// the rows.
++ 	y := 2
++ 	if len(m.bar.rows) == 0 {
++ 		b.WriteString(styFaint.Render(wrapTo("nothing running. The agent starts these itself, with your say-so.", inner)) + "\n")
++ 	}
++ 	for i, r := range m.bar.rows {
++ 		lines := m.agentRow(r, i == m.bar.cursor, inner)
++ 		b.WriteString(lines + "\n")
++ 		h := lipgloss.Height(lines)
++ 		m.bar.hits = append(m.bar.hits, rowHit{y0: y, y1: y + h - 1, id: r.ID})
++ 		y += h
++ 	}
++ 	if m.bar.focused {
++ 		b.WriteString("\n" + styFaint.Render(truncate("↑↓ move · enter open", inner)) +
++ 			"\n" + styFaint.Render(truncate("p pause · k kill · esc back", inner)))
++ 	} else {
++ 		b.WriteString("\n" + styFaint.Render(truncate("ctrl+b or click here", inner)) +
++ 			"\n" + styFaint.Render(truncate("for these agents' keys", inner)))
++ 	}
++ 	// Width is the block inside the border, padding included, so the rule
++ 	// itself is the one column not accounted for here.
++ 	return styBar.Width(width - 1).Height(maxInt(1, height)).Render(strings.TrimRight(b.String(), "\n"))
++ }
++ // agentRow is one agent: what it is on the first line, how it is going on the
++ // second. Two lines because one cannot hold both without abbreviating the
++ // numbers into uselessness.
++ func (m *model) agentRow(r subagent.Info, selected bool, width int) string {
++ 	glyph, tone := statusLook(r.Status)
++ 	marker := "  "
++ 	name := styText.Render(r.ID + "  " + r.Preset)
++ 	if selected {
++ 		marker = styCoral.Render("❯ ")
++ 		name = styBold.Foreground(colText).Render(r.ID + "  " + r.Preset)
++ 	}
++ 	if m.viewing == r.ID {
++ 		name += styCoral.Render(" ◂")
++ 	}
++ 	first := marker + tone.Render(glyph) + " " + name
++ 	// The cost goes at the right of the first line rather than at the end of
++ 	// the second: thirty columns cannot hold model, elapsed, turns and money
++ 	// on one line, and the number you look for is the money.
++ 	// Below a cent, two decimal places say "$0.00", which reads as free. The
++ 	// exact figure is in the line the transcript gets when the agent ends.
++ 	if cost, ok := r.Cost(); ok && cost >= 0.005 {
++ 		first = spread(first, styFaint.Render(fmt.Sprintf("$%.2f", cost)), width)
++ 	}
++ 	var parts []string
++ 	if r.Status == subagent.Queued {
++ 		parts = append(parts, "queued")
++ 	} else {
++ 		parts = append(parts, shortModel(r.Model))
++ 	}
++ 	switch r.Status {
++ 	case subagent.Waiting:
++ 		parts = append(parts, "waiting")
++ 	case subagent.Paused:
++ 		parts = append(parts, "paused")
++ 	case subagent.Failed:
++ 		parts = append(parts, "failed")
++ 	case subagent.Killed:
++ 		parts = append(parts, "stopped")
++ 	case subagent.Done:
++ 		parts = append(parts, "done")
++ 	default:
++ 		if d := r.Elapsed(); d > 0 {
++ 			parts = append(parts, compactDuration(d))
++ 		}
++ 	}
++ 	if r.Turns > 0 {
++ 		parts = append(parts, plural(r.Turns, "turn"))
++ 	}
++ 	second := "  " + styFaint.Render(truncate(strings.Join(parts, " · "), maxInt(6, width-2)))
++ 	return truncateStyled(first, width) + "\n" + second
++ }
++ // shortModel is the family alone — "Haiku", "Opus" — which is all a
++ // thirty-column row has space for. The full id is in the thread's header, one
++ // keystroke away.
++ func shortModel(id string) string {
++ 	pretty := prettyModel(id)
++ 	if pretty != id {
++ 		if i := strings.IndexByte(pretty, ' '); i > 0 {
++ 			return pretty[:i]
++ 		}
++ 	}
++ 	return pretty
++ }
++ // compactDuration is how long an agent has been at it. Past a minute, a count
++ // of seconds stops reading as a duration.
++ func compactDuration(d time.Duration) string {
++ 	if d < time.Minute {
++ 		return fmt.Sprintf("%ds", int(d.Seconds()))
++ 	}
++ 	return fmt.Sprintf("%dm%02ds", int(d.Minutes()), int(d.Seconds())%60)
++ }
++ // statusLook is the glyph and colour one status gets. The running glyph is the
++ // same star the status line pulses with, so a live agent looks live.
++ func statusLook(s subagent.Status) (string, lipgloss.Style) {
++ 	switch s {
++ 	case subagent.Queued:
++ 		return "◦", styFaint
++ 	case subagent.Running:
++ 		return "✳", styCoral
++ 	case subagent.Waiting:
++ 		return "●", styWarn
++ 	case subagent.Paused:
++ 		return "‖", styDim
++ 	case subagent.Done:
++ 		return "✓", styOK
++ 	case subagent.Failed:
++ 		return "✗", styErr
++ 	case subagent.Killed:
++ 		return "✗", styDim
++ 	}
++ 	return "·", styDim
++ }
++ // agentHeader is the bar above a subagent's thread, so a transcript that looks
++ // like yours cannot be mistaken for yours.
++ func (m *model) agentHeader(width int) string {
++ 	var r subagent.Info
++ 	var found bool
++ 	for _, row := range m.bar.rows {
++ 		if row.ID == m.viewing {
++ 			r, found = row, true
++ 			break
++ 		}
++ 	}
++ 	if !found {
++ 		return ""
++ 	}
++ 	glyph, tone := statusLook(r.Status)
++ 	detail := " · " + prettyModel(r.Model)
++ 	if r.Effort != "" {
++ 		detail += " · " + r.Effort + " effort"
++ 	}
++ 	detail += " · " + string(r.Status)
++ 	left := tone.Render(glyph) + " " + styHeading.Render(r.ID+" · "+r.Preset) + styDim.Render(detail)
++ 	right := styFaint.Render("esc back")
++ 	return spread(left, right, maxInt(1, width))
++ }
++ // subTranscript is the scrollback for one subagent, created on first sight.
++ func (m *model) subTranscript(id string) *transcript {
++ 	if m.subTr == nil {
++ 		m.subTr = map[string]*transcript{}
++ 	}
++ 	t, ok := m.subTr[id]
++ 	if !ok {
++ 		t = newTranscript(m.mainWidth())
++ 		t.setVerbose(m.opts.Verbose)
++ 		m.subTr[id] = t
++ 		if info, found := m.agentInfo(id); found {
++ 			t.addUser(info.Task)
++ 		}
++ 	}
++ 	return t
++ }
++ func (m *model) agentInfo(id string) (subagent.Info, bool) {
++ 	for _, r := range m.bar.rows {
++ 		if r.ID == id {
++ 			return r, true
++ 		}
++ 	}
++ 	return subagent.Info{}, false
++ }
++ // onSubEvent routes one subagent's event into that agent's transcript. It is
++ // the same handling the main thread gets, against a different transcript:
++ // tool calls, diffs and elision all behave identically.
++ func (m *model) onSubEvent(ev subagent.Event) tea.Cmd {
++ 	t := m.subTranscript(ev.ID)
++ 	switch ev.Agent.Kind {
++ 	case agent.EventTextDelta:
++ 		t.appendDelta(ev.Agent.Text)
++ 	case agent.EventText:
++ 		t.add(entry{kind: entryAssistant, text: strings.TrimSpace(ev.Agent.Text)})
++ 	case agent.EventToolStart:
++ 		t.startTool(ev.Agent.Tool, summarizeInput(ev.Agent.Input))
++ 	case agent.EventToolResult:
++ 		t.finishTool(ev.Agent.Tool, ev.Agent.Result, ev.Agent.IsError)
++ 	case agent.EventCompact:
++ 		t.addNotice("compacted the conversation")
++ 	case agent.EventPaused:
++ 		t.addNotice("paused")
++ 	case agent.EventResumed:
++ 		t.addNotice("resumed")
++ 	case agent.EventUsage:
++ 		// A child's tokens are the session's tokens: they are spent on the
++ 		// same key, and priced at the child's own model rather than at
++ 		// whatever the session happens to be on.
++ 		m.addCostAt(ev.Agent.Usage, ev.Model)
++ 		return nil
++ 	default:
++ 		return nil
++ 	}
++ 	if m.viewing == ev.ID {
++ 		return m.sync()
++ 	}
++ 	return nil
++ }
++ // onAgentsChanged is the supervisor telling us something moved: a status, or a
++ // finished agent with a report to hand over.
++ func (m *model) onAgentsChanged() tea.Cmd {
++ 	if m.opts.Agents == nil {
++ 		return nil
++ 	}
++ 	m.refreshAgents()
++ 	for _, r := range m.opts.Agents.TakeReports() {
++ 		// Queued, not delivered: whether this one is ours to hand over is
++ 		// decided when there is a turn to put it in, because agent_wait can
++ 		// take it in the meantime.
++ 		m.pendingReports = append(m.pendingReports, r)
++ 		m.tr.addNotice(agentFinishedLine(r))
++ 	}
++ 	return tea.Batch(m.sync(), m.deliverReports())
++ }
++ // agentFinishedLine is the one line your own transcript gets when an agent
++ // ends. The report itself goes to the model; this is for you.
++ func agentFinishedLine(r subagent.Info) string {
++ 	var b strings.Builder
++ 	fmt.Fprintf(&b, "%s (%s) %s", r.ID, r.Preset, endedWord(r.Status))
++ 	var parts []string
++ 	if r.Turns > 0 {
++ 		parts = append(parts, plural(r.Turns, "turn"))
++ 	}
++ 	if d := r.Elapsed(); d > 0 {
++ 		parts = append(parts, fmt.Sprintf("%ds", int(d.Seconds())))
++ 	}
++ 	if cost, ok := r.Cost(); ok && cost > 0 {
++ 		parts = append(parts, fmt.Sprintf("$%.4f", cost))
++ 	}
++ 	if len(parts) > 0 {
++ 		fmt.Fprintf(&b, " — %s", strings.Join(parts, " · "))
++ 	}
++ 	if r.Status == subagent.Failed && r.Err != "" {
++ 		fmt.Fprintf(&b, ": %s", r.Err)
++ 	}
++ 	b.WriteString(" · ctrl+b to read it")
++ 	return b.String()
++ }
++ func endedWord(s subagent.Status) string {
++ 	switch s {
++ 	case subagent.Failed:
++ 		return "failed"
++ 	case subagent.Killed:
++ 		return "was stopped"
++ 	}
++ 	return "finished"
++ }
++ // readyForReports reports whether a report can go up right now. Everything it
++ // refuses on is a case where starting a turn would take the screen away from
++ // something the user is in the middle of — most of all a prompt with text in
++ // it, which a starting turn would blur under their fingers.
++ func (m *model) readyForReports() bool {
++ 	return m.opts.Agent != nil &&
++ 		m.phase == phaseIdle &&
++ 		m.wiz == nil &&
++ 		m.running == nil &&
++ 		len(m.pending) == 0 &&
++ 		m.local == localOff &&
++ 		strings.TrimSpace(m.input.Value()) == ""
++ }
++ // deliverReports gives the agent everything that has finished, and sets it
++ // going. This is the half of the feature that makes spawning worth doing: you
++ // do not have to come back and ask how the agents got on.
++ func (m *model) deliverReports() tea.Cmd {
++ 	if len(m.pendingReports) == 0 || !m.readyForReports() {
++ 		return nil
++ 	}
++ 	// Every pending report may have been collected by agent_wait since it was
++ 	// queued, in which case there is nothing to say and no turn to start.
++ 	if !m.flushReportsAhead() {
++ 		return nil
++ 	}
++ 	m.phase = phaseRunning
++ 	m.started = time.Now()
++ 	m.turn = 0
++ 	m.verbSeed++
++ 	// The prompt keeps focus, exactly as it does for a turn you started
++ 	// yourself: typing ahead while the agent works is allowed, and this turn
++ 	// is not special for having started on its own.
++ 	return tea.Batch(m.runContinue(), m.spin.Tick, m.sync())
++ }
++ // takeReportText folds the reports this front end is still entitled to hand
++ // over into one message, and clears the queue.
++ //
++ // The claim is made here rather than when the report was drained, because the
++ // gap between the two can be minutes: the parent's own agent_wait may have
++ // collected the report in that time, and putting it in again would charge the
++ // model twice for something already in its context.
++ func (m *model) takeReportText() string {
++ 	var parts []string
++ 	for _, r := range m.pendingReports {
++ 		if m.opts.Agents != nil && !m.opts.Agents.ClaimReport(r.ID) {
++ 			continue
++ 		}
++ 		parts = append(parts, r.Notification())
++ 	}
++ 	m.pendingReports = nil
++ 	return strings.Join(parts, "\n\n")
++ }
++ // flushReportsAhead puts pending reports into the conversation as their own
++ // message, ahead of whatever the user is about to send. Gluing the two
++ // together would leave the model unable to tell which words were whose.
++ //
++ // It reports whether anything was actually added: every pending report may
++ // turn out to belong to agent_wait instead.
++ func (m *model) flushReportsAhead() bool {
++ 	if len(m.pendingReports) == 0 || m.opts.Agent == nil {
++ 		return false
++ 	}
++ 	text := m.takeReportText()
++ 	if text == "" {
++ 		return false
++ 	}
++ 	m.opts.Agent.State().Append(llm.Message{
++ 		Role:    llm.RoleUser,
++ 		Content: []llm.ContentBlock{llm.TextBlock(text)},
++ 	})
++ 	return true
++ }
++ // onMouse routes a click or a wheel. The wheel scrolls whatever pane it is
++ // over; a click on the agents pill toggles the sidebar, and a click on a row
++ // selects it — a second click on the row already selected opens its thread,
++ // which is the double-click anyone tries first.
++ func (m *model) onMouse(msg tea.MouseMsg) tea.Cmd {
++ 	if msg.Button == tea.MouseButtonWheelUp || msg.Button == tea.MouseButtonWheelDown {
++ 		if m.bar.visible() && msg.X >= m.width-m.sidebarWidth() {
++ 			// The list is short enough to fit; scrolling it would be a scroll
++ 			// bar with nothing behind it.
++ 			return nil
++ 		}
++ 		var cmd tea.Cmd
++ 		m.vp, cmd = m.vp.Update(msg)
++ 		return cmd
++ 	}
++ 	if msg.Action != tea.MouseActionPress || msg.Button != tea.MouseButtonLeft {
++ 		return nil
++ 	}
++ 	if m.opts.Agents != nil && m.pill.hit(msg.X, msg.Y) {
++ 		return m.toggleSidebar()
++ 	}
++ 	if !m.bar.visible() {
++ 		return nil
++ 	}
++ 	// A click is also a statement about where you are working: in the
++ 	// conversation, or in the pane.
++ 	if msg.X < m.width-m.sidebarWidth() {
++ 		return m.focusPrompt()
++ 	}
++ 	cmds := []tea.Cmd{m.focusSidebar()}
++ 	for i, h := range m.bar.hits {
++ 		if !h.hit(msg.X, msg.Y) {
++ 			continue
++ 		}
++ 		if m.bar.cursor == i && m.viewing != h.id {
++ 			m.viewing = h.id
++ 		} else {
++ 			m.bar.cursor = i
++ 		}
++ 		return tea.Batch(append(cmds, m.followSelection())...)
++ 	}
++ 	return tea.Batch(cmds...)
++ }
++ // toggleMouse answers /mouse. Reporting is on by default because it buys the
++ // clickable pill and the wheel; it is turnable off because it takes the
++ // terminal's own text selection with it, and copying a stack trace out of the
++ // transcript matters more than clicking.
++ func (m *model) toggleMouse() tea.Cmd {
++ 	m.mouseOn = !m.mouseOn
++ 	if m.mouseOn {
++ 		m.tr.addNotice("mouse on — clicks and the wheel work; your terminal's own text selection may need shift held down")
++ 		return tea.Batch(m.sync(), tea.EnableMouseCellMotion)
++ 	}
++ 	m.tr.addNotice("mouse off — select and copy text as usual; /mouse turns it back on")
++ 	return tea.Batch(m.sync(), tea.DisableMouse)
++ }
++ // wrapTo is a minimal hard wrap for the pane's own hint text.
++ func wrapTo(s string, width int) string {
++ 	if width <= 0 {
++ 		return s
++ 	}
++ 	var lines []string
++ 	line := ""
++ 	for _, word := range strings.Fields(s) {
++ 		switch {
++ 		case line == "":
++ 			line = word
++ 		case len(line)+1+len(word) <= width:
++ 			line += " " + word
++ 		default:
++ 			lines = append(lines, line)
++ 			line = word
++ 		}
++ 	}
++ 	if line != "" {
++ 		lines = append(lines, line)
++ 	}
++ 	return strings.Join(lines, "\n")
++ }

+1002−0internal/tui/sidebar_test.goaddedView File

++ package tui
++ import (
++ 	"context"
++ 	"strings"
++ 	"testing"
++ 	"time"
++ 	tea "github.com/charmbracelet/bubbletea"
++ 	"github.com/charmbracelet/lipgloss"
++ 	"harness/internal/agent"
++ 	"harness/internal/approval"
++ 	"harness/internal/llm"
++ 	"harness/internal/metrics"
++ 	"harness/internal/subagent"
++ 	"harness/internal/tools"
++ )
++ // fakeAgents stands in for the supervisor: the TUI only ever asks it for a
++ // snapshot, takes finished reports off it, and tells it to pause, resume or
++ // kill by id.
++ type fakeAgents struct {
++ 	rows    []subagent.Info
++ 	reports []subagent.Info
++ 	acted   []string
++ 	// onAct fires inside Pause/Resume/Kill, standing in for the real
++ 	// supervisor's Changed callback — which reaches the program through an
++ 	// unbuffered channel the update loop is the only reader of.
++ 	onAct func()
++ 	// unclaimable are reports the supervisor has already handed to the model
++ 	// another way, which the front end must not send again.
++ 	unclaimable map[string]bool
++ }
++ func (f *fakeAgents) Snapshot() []subagent.Info    { return f.rows }
++ func (f *fakeAgents) TakeReports() []subagent.Info { r := f.reports; f.reports = nil; return r }
++ func (f *fakeAgents) Live() int {
++ 	var n int
++ 	for _, r := range f.rows {
++ 		if r.Status.Live() {
++ 			n++
++ 		}
++ 	}
++ 	return n
++ }
++ func (f *fakeAgents) act(what string) error {
++ 	f.acted = append(f.acted, what)
++ 	if f.onAct != nil {
++ 		f.onAct()
++ 	}
++ 	return nil
++ }
++ func (f *fakeAgents) Pause(id string) error                  { return f.act("pause " + id) }
++ func (f *fakeAgents) Resume(id string) error                 { return f.act("resume " + id) }
++ func (f *fakeAgents) Kill(id string) error                   { return f.act("kill " + id) }
++ func (f *fakeAgents) Subscribe(func(subagent.Event), func()) {}
++ // ClaimReport refuses a report the model has already been given another way.
++ func (f *fakeAgents) ClaimReport(id string) bool { return !f.unclaimable[id] }
++ func info(id, preset string, status subagent.Status) subagent.Info {
++ 	return subagent.Info{
++ 		ID: id, Preset: preset, Model: "claude-haiku-4-5", Task: "do the thing",
++ 		Status: status, Turns: 3, Started: time.Now().Add(-20 * time.Second),
++ 		Usage: llm.Usage{InputTokens: 1000, OutputTokens: 200},
++ 	}
++ }
++ // newAgentModel is a model with a sidebar to drive.
++ func newAgentModel(t *testing.T, rows ...subagent.Info) (*model, *fakeAgents) {
++ 	t.Helper()
++ 	f := &fakeAgents{rows: rows}
++ 	m := newModel(context.Background(), Options{
++ 		Client: llm.New(llm.WithAPIKey("x")),
++ 		Root:   "/tmp/repo",
++ 		Policy: approval.New(nil),
++ 		Agents: f,
++ 	})
++ 	m.Update(tea.WindowSizeMsg{Width: 100, Height: 30})
++ 	m.Update(evAgents{})
++ 	return m, f
++ }
++ func TestCtrlBOpensAndClosesTheSidebar(t *testing.T) {
++ 	m, _ := newAgentModel(t, info("a1", "explore", subagent.Running))
++ 	if strings.Contains(m.View(), "explore") {
++ 		t.Fatal("the sidebar is showing before it was opened")
++ 	}
++ 	m.Update(key("ctrl+b"))
++ 	if !strings.Contains(m.View(), "explore") {
++ 		t.Fatalf("ctrl+b did not open the sidebar:\n%s", m.View())
++ 	}
++ 	m.Update(key("ctrl+b"))
++ 	if strings.Contains(m.View(), "explore") {
++ 		t.Error("ctrl+b did not close the sidebar again")
++ 	}
++ }
++ // The row is what tells you whether an agent is working or stuck, so it has to
++ // carry the id, the preset, the model and the numbers.
++ func TestARowNamesTheAgentAndWhatItCosts(t *testing.T) {
++ 	m, _ := newAgentModel(t, info("a1", "explore", subagent.Running))
++ 	m.Update(key("ctrl+b"))
++ 	view := m.View()
++ 	for _, want := range []string{"a1", "explore", "Haiku", "3 turns"} {
++ 		if !strings.Contains(view, want) {
++ 			t.Errorf("the sidebar never says %q:\n%s", want, view)
++ 		}
++ 	}
++ }
++ func TestEveryStatusIsLegibleInTheSidebar(t *testing.T) {
++ 	rows := []subagent.Info{
++ 		info("a1", "explore", subagent.Queued),
++ 		info("a2", "plan", subagent.Running),
++ 		info("a3", "general", subagent.Waiting),
++ 		info("a4", "explore", subagent.Paused),
++ 		info("a5", "plan", subagent.Done),
++ 		info("a6", "general", subagent.Failed),
++ 		info("a7", "explore", subagent.Killed),
++ 	}
++ 	m, _ := newAgentModel(t, rows...)
++ 	m.Update(key("ctrl+b"))
++ 	view := m.View()
++ 	for _, r := range rows {
++ 		if !strings.Contains(view, r.ID) {
++ 			t.Errorf("%s (%s) is missing from the sidebar:\n%s", r.ID, r.Status, view)
++ 		}
++ 	}
++ 	for _, word := range []string{"queued", "waiting", "paused", "done", "failed", "stopped"} {
++ 		if !strings.Contains(view, word) {
++ 			t.Errorf("no row reads as %q:\n%s", word, view)
++ 		}
++ 	}
++ }
++ // Selecting an agent shows its own transcript in the main pane: the one place
++ // the turns it took are visible at all.
++ func TestOpeningAnAgentShowsItsOwnThread(t *testing.T) {
++ 	m, _ := newAgentModel(t, info("a1", "explore", subagent.Running), info("a2", "plan", subagent.Running))
++ 	m.tr.addUser("what my own thread says")
++ 	m.Update(evSub{ev: subagent.Event{ID: "a1", Preset: "explore",
++ 		Agent: agent.Event{Kind: agent.EventText, Text: "what the first agent said"}}})
++ 	m.Update(evSub{ev: subagent.Event{ID: "a2", Preset: "plan",
++ 		Agent: agent.Event{Kind: agent.EventText, Text: "what the second agent said"}}})
++ 	m.Update(key("ctrl+b"))
++ 	m.Update(key("enter"))
++ 	view := m.View()
++ 	if !strings.Contains(view, "what the first agent said") {
++ 		t.Fatalf("a1's thread is not on screen:\n%s", view)
++ 	}
++ 	if strings.Contains(view, "what my own thread says") {
++ 		t.Error("the main thread is still on screen underneath the agent's")
++ 	}
++ 	m.Update(key("down"))
++ 	m.Update(key("enter"))
++ 	view = m.View()
++ 	if !strings.Contains(view, "what the second agent said") {
++ 		t.Fatalf("moving to a2 did not show its thread:\n%s", view)
++ 	}
++ 	if strings.Contains(view, "what the first agent said") {
++ 		t.Error("a1's thread is still showing while a2 is selected")
++ 	}
++ }
++ func TestEscLeavesTheThreadThenClosesTheSidebar(t *testing.T) {
++ 	m, _ := newAgentModel(t, info("a1", "explore", subagent.Running))
++ 	m.tr.addUser("my own thread")
++ 	m.Update(evSub{ev: subagent.Event{ID: "a1", Preset: "explore",
++ 		Agent: agent.Event{Kind: agent.EventText, Text: "the agent's thread"}}})
++ 	m.Update(key("ctrl+b"))
++ 	m.Update(key("enter"))
++ 	m.Update(key("esc"))
++ 	if m.viewing != "" {
++ 		t.Errorf("still viewing %q after esc", m.viewing)
++ 	}
++ 	if !strings.Contains(m.View(), "explore") {
++ 		t.Error("esc closed the whole sidebar rather than leaving the thread")
++ 	}
++ 	if !strings.Contains(m.View(), "my own thread") {
++ 		t.Error("esc did not put your own thread back")
++ 	}
++ 	m.Update(key("esc"))
++ 	if strings.Contains(m.View(), "explore") {
++ 		t.Error("a second esc did not close the sidebar")
++ 	}
++ }
++ func TestPauseResumeAndKillActOnTheSelectedAgent(t *testing.T) {
++ 	m, f := newAgentModel(t,
++ 		info("a1", "explore", subagent.Running),
++ 		info("a2", "plan", subagent.Paused),
++ 	)
++ 	m.Update(key("ctrl+b"))
++ 	press(t, m, key("p")) // a1 is running, so p pauses it
++ 	press(t, m, key("down"))
++ 	press(t, m, key("p")) // a2 is paused, so p resumes it
++ 	press(t, m, key("k"))
++ 	if strings.Join(f.acted, ", ") != "pause a1, resume a2, kill a2" {
++ 		t.Errorf("the sidebar asked for %v", f.acted)
++ 	}
++ }
++ // Pausing or killing must happen off the update loop. The supervisor tells
++ // the front end that something changed by sending it a message, and the
++ // channel that carries it is read by the update loop itself — so a supervisor
++ // call made from inside Update deadlocks the whole program, keyboard included.
++ func TestControllingAnAgentHappensOffTheUpdateLoop(t *testing.T) {
++ 	m, f := newAgentModel(t, info("a1", "explore", subagent.Running))
++ 	m.Update(key("ctrl+b"))
++ 	var inUpdate, calledInUpdate bool
++ 	f.onAct = func() {
++ 		if inUpdate {
++ 			calledInUpdate = true
++ 		}
++ 	}
++ 	inUpdate = true
++ 	_, cmd := m.Update(key("p"))
++ 	inUpdate = false
++ 	if calledInUpdate {
++ 		t.Fatal("the supervisor was called from inside Update, which deadlocks the program")
++ 	}
++ 	if cmd == nil {
++ 		t.Fatal("pressing p produced no command, so nothing will ever pause the agent")
++ 	}
++ 	drain(t, m, cmd)
++ 	if len(f.acted) != 1 || f.acted[0] != "pause a1" {
++ 		t.Errorf("after the command ran, the supervisor saw %v", f.acted)
++ 	}
++ }
++ // press feeds a key and then runs whatever command came back, the way the
++ // program's scheduler would.
++ func press(t *testing.T, m *model, msg tea.Msg) {
++ 	t.Helper()
++ 	_, cmd := m.Update(msg)
++ 	drain(t, m, cmd)
++ }
++ // While the sidebar has the keys, what you type must not land in the prompt —
++ // otherwise "k" both kills an agent and types a letter.
++ func TestKeysGoToTheSidebarNotThePromptWhileItIsOpen(t *testing.T) {
++ 	m, _ := newAgentModel(t, info("a1", "explore", subagent.Running))
++ 	m.Update(key("ctrl+b"))
++ 	typeIn(m, "pk")
++ 	if got := m.input.Value(); got != "" {
++ 		t.Errorf("the prompt swallowed %q while the sidebar was open", got)
++ 	}
++ 	m.Update(key("esc"))
++ 	typeIn(m, "hello")
++ 	if got := m.input.Value(); got != "hello" {
++ 		t.Errorf("after esc the prompt has %q, want %q", got, "hello")
++ 	}
++ }
++ // A subagent's events belong to its own transcript, not to yours.
++ func TestSubagentOutputNeverLandsInTheMainTranscript(t *testing.T) {
++ 	m, _ := newAgentModel(t, info("a1", "explore", subagent.Running))
++ 	m.Update(evSub{ev: subagent.Event{ID: "a1", Preset: "explore",
++ 		Agent: agent.Event{Kind: agent.EventToolStart, Tool: "grep", Input: []byte(`{"pattern":"x"}`)}}})
++ 	if strings.Contains(m.tr.render(), "grep") {
++ 		t.Errorf("the agent's tool call landed in the main transcript:\n%s", m.tr.render())
++ 	}
++ }
++ // A finished agent is worth a line in your own transcript even when its report
++ // is not being delivered yet: an agent that finishes invisibly is one you go
++ // looking for.
++ func TestAFinishedAgentIsNoticedInTheMainTranscript(t *testing.T) {
++ 	m, f := newAgentModel(t, info("a1", "explore", subagent.Running))
++ 	done := info("a1", "explore", subagent.Done)
++ 	done.Report = "found it in loop.go"
++ 	f.rows = []subagent.Info{done}
++ 	f.reports = []subagent.Info{done}
++ 	typeIn(m, "half a sentence") // holds the report back
++ 	m.Update(evAgents{})
++ 	if !strings.Contains(m.tr.render(), "a1") {
++ 		t.Errorf("nothing in the transcript says a1 finished:\n%s", m.tr.render())
++ 	}
++ }
++ // A turn must not start under your fingers: it blurs the prompt and eats what
++ // you were typing.
++ func TestAReportIsHeldWhileYouAreTyping(t *testing.T) {
++ 	m, f := newAgentModel(t, info("a1", "explore", subagent.Done))
++ 	f.reports = []subagent.Info{info("a1", "explore", subagent.Done)}
++ 	typeIn(m, "half a sentence")
++ 	m.Update(evAgents{})
++ 	if len(m.pendingReports) != 1 {
++ 		t.Fatalf("the report was not held: %d pending", len(m.pendingReports))
++ 	}
++ 	if m.phase != phaseIdle {
++ 		t.Errorf("a turn started while the prompt had text in it")
++ 	}
++ 	if got := m.input.Value(); got != "half a sentence" {
++ 		t.Errorf("the prompt now reads %q", got)
++ 	}
++ }
++ func TestReportsAreHeldWhileAnApprovalIsOnScreen(t *testing.T) {
++ 	m, f := newAgentModel(t, info("a1", "explore", subagent.Done))
++ 	f.reports = []subagent.Info{info("a1", "explore", subagent.Done)}
++ 	pend(m, approval.Request{Tool: "bash", Summary: "run something"})
++ 	m.Update(evAgents{})
++ 	if len(m.pendingReports) != 1 {
++ 		t.Fatalf("the report was not held while an approval was up")
++ 	}
++ }
++ // Idle and empty-handed, the report goes into the conversation by itself and
++ // the agent is set going on it — no keystroke required.
++ func TestAReportStartsATurnWhenYouAreIdle(t *testing.T) {
++ 	m, f := newAgentModel(t, info("a1", "explore", subagent.Done))
++ 	m.opts.Agent = newQuietAgent(t)
++ 	done := info("a1", "explore", subagent.Done)
++ 	done.Report = "found it in loop.go"
++ 	f.reports = []subagent.Info{done}
++ 	m.Update(evAgents{})
++ 	if len(m.pendingReports) != 0 {
++ 		t.Fatalf("the report is still pending with nothing in the way")
++ 	}
++ 	if m.phase != phaseRunning {
++ 		t.Errorf("phase = %v, want a turn to have started", m.phase)
++ 	}
++ 	var sent string
++ 	for _, msg := range m.opts.Agent.State().History() {
++ 		for _, b := range msg.Content {
++ 			sent += b.Text
++ 		}
++ 	}
++ 	if !strings.Contains(sent, "found it in loop.go") {
++ 		t.Errorf("the conversation never got the report:\n%s", sent)
++ 	}
++ }
++ // Whatever was typed before the report landed is still yours to send, and the
++ // report goes up ahead of it rather than being glued onto it.
++ func TestAHeldReportGoesUpWhenYouSendYourOwnMessage(t *testing.T) {
++ 	m, f := newAgentModel(t, info("a1", "explore", subagent.Done))
++ 	m.opts.Agent = newQuietAgent(t)
++ 	done := info("a1", "explore", subagent.Done)
++ 	done.Report = "found it in loop.go"
++ 	f.reports = []subagent.Info{done}
++ 	typeIn(m, "and now fix it")
++ 	m.Update(evAgents{})
++ 	m.Update(key("enter"))
++ 	history := m.opts.Agent.State().History()
++ 	if len(history) != 1 {
++ 		t.Fatalf("history has %d messages, want the report as its own message", len(history))
++ 	}
++ 	if !strings.Contains(history[0].Content[0].Text, "found it in loop.go") {
++ 		t.Errorf("the report did not go up ahead of the message:\n%+v", history[0])
++ 	}
++ 	if len(m.pendingReports) != 0 {
++ 		t.Error("the report is still pending after a turn started")
++ 	}
++ }
++ // newQuietAgent is a real agent whose turns are never actually run: the tests
++ // above stop at the command, so nothing reaches the network.
++ func newQuietAgent(t *testing.T) *agent.Agent {
++ 	t.Helper()
++ 	log := metrics.NewWriter(nil, "test")
++ 	state := agent.NewState()
++ 	reg := tools.NewRegistry(log)
++ 	return agent.New(llm.New(llm.WithAPIKey("x")), reg, state, log, agent.Options{})
++ }
++ // A sub-cent agent showing "$0.00" reads as free. Below a cent the row says
++ // nothing, and the line in the transcript gives the exact figure.
++ func TestSubCentCostsAreNotShownAsZero(t *testing.T) {
++ 	cheap := info("a1", "explore", subagent.Done)
++ 	cheap.Usage = llm.Usage{InputTokens: 1000, OutputTokens: 40}
++ 	dear := info("a2", "plan", subagent.Done)
++ 	dear.Model = "claude-opus-5"
++ 	dear.Usage = llm.Usage{InputTokens: 100000, OutputTokens: 4000}
++ 	m, _ := newAgentModel(t, cheap, dear)
++ 	m.Update(key("ctrl+b"))
++ 	view := m.View()
++ 	if strings.Contains(view, "$0.00") {
++ 		t.Errorf("a sub-cent agent is shown as costing nothing:\n%s", view)
++ 	}
++ 	if !strings.Contains(view, "$0.6") {
++ 		t.Errorf("the expensive agent's cost is missing:\n%s", view)
++ 	}
++ }
++ // Thirty columns is not enough for "claude-haiku-4-5" and a duration and a
++ // turn count, so the row carries the family and the thread's header carries
++ // the rest.
++ func TestShortModelKeepsTheFamily(t *testing.T) {
++ 	cases := map[string]string{
++ 		"claude-haiku-4-5":           "Haiku",
++ 		"claude-opus-5":              "Opus",
++ 		"claude-haiku-4-5-20251001":  "Haiku",
++ 		"some-gateway/mistral-large": "some-gateway/mistral-large",
++ 		"":                           "",
++ 	}
++ 	for id, want := range cases {
++ 		if got := shortModel(id); got != want {
++ 			t.Errorf("shortModel(%q) = %q, want %q", id, got, want)
++ 		}
++ 	}
++ }
++ // A minute in, "124s" stops being a number anyone reads as a duration.
++ func TestCompactDurationTurnsMinutesIntoMinutes(t *testing.T) {
++ 	cases := []struct {
++ 		d    time.Duration
++ 		want string
++ 	}{
++ 		{3 * time.Second, "3s"},
++ 		{59 * time.Second, "59s"},
++ 		{time.Minute + 4*time.Second, "1m04s"},
++ 		{124 * time.Second, "2m04s"},
++ 		{2 * time.Hour, "120m00s"},
++ 	}
++ 	for _, c := range cases {
++ 		if got := compactDuration(c.d); got != c.want {
++ 			t.Errorf("compactDuration(%v) = %q, want %q", c.d, got, c.want)
++ 		}
++ 	}
++ }
++ // The pane is the full height of the screen: two short rows leave the status
++ // line running under it with nothing beside it.
++ func TestTheSidebarIsAsTallAsTheScreen(t *testing.T) {
++ 	m, _ := newAgentModel(t, info("a1", "explore", subagent.Running))
++ 	m.Update(tea.WindowSizeMsg{Width: 78, Height: 16})
++ 	m.Update(key("ctrl+b"))
++ 	for i, line := range strings.Split(m.View(), "\n") {
++ 		if !strings.Contains(line, "│") {
++ 			t.Errorf("line %d has no sidebar beside it: %q", i, line)
++ 		}
++ 	}
++ }
++ // Nothing the model draws may be wider than the terminal it is drawn in: a
++ // composite that overflows wraps, and a wrapped full-screen layout tears.
++ func TestTheWholeScreenFitsTheTerminalWithTheSidebarOpen(t *testing.T) {
++ 	m, _ := newAgentModel(t, info("a1", "explore", subagent.Running))
++ 	for _, size := range []tea.WindowSizeMsg{{Width: 78, Height: 14}, {Width: 100, Height: 30}, {Width: 62, Height: 20}} {
++ 		m.Update(size)
++ 		m.Update(evAgents{})
++ 		for _, open := range []bool{true, false} {
++ 			if m.bar.open != open {
++ 				m.Update(key("ctrl+b"))
++ 			}
++ 			for i, line := range strings.Split(m.View(), "\n") {
++ 				if w := lipgloss.Width(line); w > size.Width {
++ 					t.Errorf("at %dx%d (sidebar open=%v) line %d is %d columns wide",
++ 						size.Width, size.Height, open, i, w)
++ 				}
++ 			}
++ 		}
++ 	}
++ }
++ // The sidebar owns the keyboard while it is open, with two exceptions: the
++ // keys that stop things. Swallowing ctrl+c would mean opening the pane to
++ // watch an agent left you unable to interrupt your own turn.
++ func TestInterruptAndExitStillWorkWithTheSidebarOpen(t *testing.T) {
++ 	m, _ := newAgentModel(t, info("a1", "explore", subagent.Running))
++ 	m.phase = phaseRunning
++ 	var interrupted bool
++ 	m.cancel = func() { interrupted = true }
++ 	m.Update(key("ctrl+b"))
++ 	m.Update(key("ctrl+c"))
++ 	if !interrupted {
++ 		t.Error("ctrl+c did not interrupt the turn while the sidebar was open")
++ 	}
++ 	m.phase = phaseIdle
++ 	m.Update(key("ctrl+d"))
++ 	if !m.quitting {
++ 		t.Error("ctrl+d did not exit while the sidebar was open")
++ 	}
++ }
++ // click presses the left button where the model says something is drawn.
++ func click(x, y int) tea.MouseMsg {
++ 	return tea.MouseMsg{X: x, Y: y, Action: tea.MouseActionPress, Button: tea.MouseButtonLeft}
++ }
++ func TestClickingTheAgentsPillTogglesTheSidebar(t *testing.T) {
++ 	m, _ := newAgentModel(t, info("a1", "explore", subagent.Running))
++ 	m.View() // the pill's position is recorded as it is drawn
++ 	if m.pill.x1 == 0 {
++ 		t.Fatal("the agents pill was never drawn, so it cannot be clicked")
++ 	}
++ 	m.Update(click(m.pill.x0, m.pill.y0))
++ 	if !m.bar.open {
++ 		t.Error("clicking the pill did not open the sidebar")
++ 	}
++ 	m.View()
++ 	m.Update(click(m.pill.x0, m.pill.y0))
++ 	if m.bar.open {
++ 		t.Error("clicking the pill again did not close it")
++ 	}
++ }
++ // One click selects a row; clicking the row already under the cursor opens it,
++ // which is what anyone who double-clicks gets.
++ func TestClickingARowSelectsItAndClickingAgainOpensIt(t *testing.T) {
++ 	m, _ := newAgentModel(t,
++ 		info("a1", "explore", subagent.Running),
++ 		info("a2", "plan", subagent.Running),
++ 	)
++ 	m.Update(key("ctrl+b"))
++ 	m.View()
++ 	if len(m.bar.hits) != 2 {
++ 		t.Fatalf("the sidebar recorded %d clickable rows, want 2", len(m.bar.hits))
++ 	}
++ 	second := m.bar.hits[1]
++ 	x := m.width - sidebarWidth + 2
++ 	m.Update(click(x, second.y0))
++ 	if cur, _ := m.bar.selected(); cur.ID != "a2" {
++ 		t.Fatalf("clicking a2's row selected %q", cur.ID)
++ 	}
++ 	if m.viewing != "" {
++ 		t.Error("one click opened the thread; it should only select")
++ 	}
++ 	m.View()
++ 	m.Update(click(x, second.y0))
++ 	if m.viewing != "a2" {
++ 		t.Errorf("clicking the selected row did not open it; viewing = %q", m.viewing)
++ 	}
++ }
++ // A click in the transcript is not a click in the sidebar, however far right
++ // it lands while the pane is closed.
++ func TestClicksOutsideTheSidebarDoNothing(t *testing.T) {
++ 	m, _ := newAgentModel(t, info("a1", "explore", subagent.Running))
++ 	m.View()
++ 	m.Update(click(m.width-2, 3))
++ 	if m.bar.open || m.viewing != "" {
++ 		t.Error("a click in the transcript opened the sidebar")
++ 	}
++ }
++ func TestMouseCommandTogglesReporting(t *testing.T) {
++ 	m, _ := newAgentModel(t, info("a1", "explore", subagent.Running))
++ 	m.mouseOn = true
++ 	m.submit("/mouse")
++ 	if m.mouseOn {
++ 		t.Error("/mouse did not turn reporting off")
++ 	}
++ 	if !strings.Contains(m.tr.render(), "mouse off") {
++ 		t.Errorf("nothing said what happened:\n%s", m.tr.render())
++ 	}
++ 	m.submit("/mouse")
++ 	if !m.mouseOn {
++ 		t.Error("/mouse did not turn reporting back on")
++ 	}
++ }
++ // The rows' click targets have to agree with where the rows were actually
++ // drawn. Recorded coordinates that are internally consistent but a line off
++ // the screen would make every click select the row above.
++ func TestRowClickTargetsMatchWhereTheRowsAreDrawn(t *testing.T) {
++ 	m, _ := newAgentModel(t,
++ 		info("a1", "explore", subagent.Running),
++ 		info("a2", "plan", subagent.Running),
++ 		info("a3", "general", subagent.Done),
++ 	)
++ 	m.Update(key("ctrl+b"))
++ 	lines := strings.Split(m.View(), "\n")
++ 	if len(m.bar.hits) != 3 {
++ 		t.Fatalf("recorded %d click targets, want 3", len(m.bar.hits))
++ 	}
++ 	for _, h := range m.bar.hits {
++ 		if h.y0 >= len(lines) {
++ 			t.Fatalf("row %s is recorded at line %d of a %d-line screen", h.id, h.y0, len(lines))
++ 		}
++ 		if !strings.Contains(lines[h.y0], h.id) {
++ 			t.Errorf("row %s is recorded at line %d, which reads %q", h.id, h.y0, lines[h.y0])
++ 		}
++ 	}
++ }
++ // The same for the pill: it is on the line it says it is.
++ func TestThePillIsRecordedOnTheLineItIsDrawnOn(t *testing.T) {
++ 	m, _ := newAgentModel(t, info("a1", "explore", subagent.Running))
++ 	lines := strings.Split(m.View(), "\n")
++ 	if m.pill.y0 >= len(lines) || !strings.Contains(lines[m.pill.y0], "agents") {
++ 		t.Errorf("the pill is recorded at line %d, which reads %q", m.pill.y0, lines[m.pill.y0])
++ 	}
++ }
++ // A subagent's approval can arrive when nothing of yours is running, and
++ // answering it must leave the session where it found it. Dropping into
++ // "running" with no turn in flight strands the UI: enter is refused, esc only
++ // says "interrupting", and no further report is ever delivered.
++ func TestAnsweringASubagentsApprovalWhileIdleLeavesYouIdle(t *testing.T) {
++ 	m, _ := newAgentModel(t, info("a1", "explore", subagent.Running))
++ 	reply := pend(m, approval.Request{Tool: "bash", Summary: "run something", Agent: "a1"})
++ 	if m.phase != phaseApproving {
++ 		t.Fatalf("phase = %v while an approval is up", m.phase)
++ 	}
++ 	m.Update(key("y"))
++ 	if got := <-reply; got != approval.Once {
++ 		t.Fatalf("decision = %v", got)
++ 	}
++ 	if m.phase != phaseIdle {
++ 		t.Errorf("phase = %v after answering; nothing of yours was running", m.phase)
++ 	}
++ 	// The prompt is usable again, which is the thing being stranded costs you.
++ 	typeIn(m, "next")
++ 	if m.input.Value() != "next" {
++ 		t.Errorf("the prompt has %q", m.input.Value())
++ 	}
++ }
++ // The same approval answered during a turn puts the turn back.
++ func TestAnsweringAnApprovalDuringATurnStaysRunning(t *testing.T) {
++ 	m, _ := newAgentModel(t)
++ 	m.phase = phaseRunning
++ 	reply := pend(m, approval.Request{Tool: "bash", Summary: "run something"})
++ 	m.Update(key("y"))
++ 	<-reply
++ 	if m.phase != phaseRunning {
++ 		t.Errorf("phase = %v, want the turn to carry on", m.phase)
++ 	}
++ }
++ // A turn ending cancels the approvals that belonged to it — but a subagent's
++ // approval belongs to the subagent, which is still running. Denying it because
++ // the parent finished takes the decision away from the user and tells the
++ // child it was refused.
++ func TestATurnEndingLeavesSubagentApprovalsAlone(t *testing.T) {
++ 	m, _ := newAgentModel(t, info("a1", "explore", subagent.Running))
++ 	m.phase = phaseRunning
++ 	mine := pend(m, approval.Request{Tool: "bash", Summary: "the parent's"})
++ 	child := pend(m, approval.Request{Tool: "bash", Summary: "the child's", Agent: "a1"})
++ 	m.Update(turnDone{})
++ 	select {
++ 	case got := <-mine:
++ 		if got != approval.Deny {
++ 			t.Errorf("the parent's own request ended as %v, want denied", got)
++ 		}
++ 	default:
++ 		t.Error("the parent's request was left hanging after its turn ended")
++ 	}
++ 	select {
++ 	case got := <-child:
++ 		t.Fatalf("the child's request was answered %v by a turn it had nothing to do with", got)
++ 	default:
++ 	}
++ 	if len(m.pending) != 1 || m.pending[0].req.Agent != "a1" {
++ 		t.Fatalf("pending = %+v, want the child's request still waiting", m.pending)
++ 	}
++ 	if m.phase != phaseApproving {
++ 		t.Errorf("phase = %v, want the box still up for the child", m.phase)
++ 	}
++ }
++ // A report the agent already collected with agent_wait is worth a line in the
++ // transcript, and nothing more: sending it again would repeat it in the
++ // conversation and start a turn to acknowledge something it just read.
++ func TestAReportTheAgentAlreadyHasIsNotSentAgain(t *testing.T) {
++ 	m, f := newAgentModel(t, info("a1", "explore", subagent.Done))
++ 	m.opts.Agent = newQuietAgent(t)
++ 	done := info("a1", "explore", subagent.Done)
++ 	done.Report = "found it in loop.go"
++ 	f.unclaimable = map[string]bool{"a1": true}
++ 	f.reports = []subagent.Info{done}
++ 	m.Update(evAgents{})
++ 	if len(m.pendingReports) != 0 {
++ 		t.Errorf("%d reports are queued for a conversation that already has them", len(m.pendingReports))
++ 	}
++ 	if m.phase != phaseIdle {
++ 		t.Error("a turn was started to hand over a report the agent already read")
++ 	}
++ 	if len(m.opts.Agent.State().History()) != 0 {
++ 		t.Error("the report went into the conversation twice")
++ 	}
++ 	if !strings.Contains(m.tr.render(), "a1") {
++ 		t.Errorf("the transcript never mentions that a1 finished:\n%s", m.tr.render())
++ 	}
++ }
++ // With several agents running, "bash wants to run …" is not a question anyone
++ // can answer: the box has to say who is asking.
++ func TestTheApprovalBoxNamesTheAgentAsking(t *testing.T) {
++ 	m, _ := newAgentModel(t, info("a3", "explore", subagent.Running))
++ 	pend(m, approval.Request{Tool: "bash", Summary: "run a shell command", Detail: "rm -rf build", Agent: "a3"})
++ 	view := m.View()
++ 	if !strings.Contains(view, "a3") {
++ 		t.Errorf("the approval box does not say which agent is asking:\n%s", view)
++ 	}
++ 	if !strings.Contains(view, "explore") {
++ 		t.Errorf("the approval box does not say what kind of agent it is:\n%s", view)
++ 	}
++ }
++ // Your own agent's requests are not labelled: there is nobody else it could be.
++ func TestYourOwnApprovalIsNotLabelledWithAnAgent(t *testing.T) {
++ 	m, _ := newAgentModel(t)
++ 	m.phase = phaseRunning
++ 	pend(m, approval.Request{Tool: "bash", Summary: "run a shell command"})
++ 	if got := m.View(); strings.Contains(got, " · bash") {
++ 		t.Errorf("the box labels the session's own request as if it came from an agent:\n%s", got)
++ 	}
++ }
++ // On a terminal too narrow for both panes the status line is not drawn, so the
++ // pill is nowhere — and a click at its remembered position must not toggle the
++ // pane shut from under a hint line that happens to be there instead.
++ func TestThePillIsForgottenWhenTheStatusLineIsNotDrawn(t *testing.T) {
++ 	m, _ := newAgentModel(t, info("a1", "explore", subagent.Running))
++ 	m.View()
++ 	was := m.pill
++ 	m.Update(tea.WindowSizeMsg{Width: 50, Height: 20})
++ 	m.Update(key("ctrl+b"))
++ 	if !m.fullScreenSidebar() {
++ 		t.Fatal("50 columns should not be showing both panes")
++ 	}
++ 	m.View()
++ 	m.Update(click(was.x0, was.y0))
++ 	if !m.bar.open {
++ 		t.Error("a click where the pill used to be closed the pane")
++ 	}
++ }
++ // A report held back because you were typing goes up as soon as the prompt is
++ // empty again, rather than waiting for something else to happen.
++ func TestAHeldReportGoesUpWhenThePromptIsClearedAgain(t *testing.T) {
++ 	m, f := newAgentModel(t, info("a1", "explore", subagent.Done))
++ 	m.opts.Agent = newQuietAgent(t)
++ 	done := info("a1", "explore", subagent.Done)
++ 	done.Report = "found it in loop.go"
++ 	f.reports = []subagent.Info{done}
++ 	typeIn(m, "ab")
++ 	m.Update(evAgents{})
++ 	if len(m.pendingReports) != 1 {
++ 		t.Fatal("the report was not held while the prompt had text in it")
++ 	}
++ 	m.Update(key("backspace"))
++ 	m.Update(key("backspace"))
++ 	if len(m.pendingReports) != 0 {
++ 		t.Errorf("clearing the prompt did not release the report")
++ 	}
++ 	if m.phase != phaseRunning {
++ 		t.Errorf("phase = %v, want the turn to have started", m.phase)
++ 	}
++ }
++ // The effort pill is a claim about what the next turn will ask for. On a model
++ // that does not take the level, the request goes out without it — so the pill
++ // has to say so rather than reporting a setting that is not in force.
++ func TestTheEffortPillSaysWhenTheModelIgnoresIt(t *testing.T) {
++ 	m, _ := newAgentModel(t)
++ 	m.opts.Effort = "high"
++ 	m.opts.Client.SetModel("claude-opus-5")
++ 	if got := m.View(); !strings.Contains(got, "● high") || strings.Contains(got, "not on") {
++ 		t.Errorf("on a model that takes effort the pill should read plainly:\n%s", got)
++ 	}
++ 	m.opts.Client.SetModel("claude-haiku-4-5")
++ 	view := m.View()
++ 	if !strings.Contains(view, "high") {
++ 		t.Fatalf("the pill vanished entirely:\n%s", view)
++ 	}
++ 	if !strings.Contains(view, "not on Haiku") {
++ 		t.Errorf("the pill still claims a level the model rejects:\n%s", view)
++ 	}
++ }
++ // The front end holds a report from the moment it is drained until the moment
++ // there is a turn to put it in, and agent_wait can hand the same report to the
++ // model in between. So delivery is decided when the message is written, by
++ // asking the supervisor — not by trusting a copy taken minutes earlier.
++ func TestAReportTheModelWasGivenMeanwhileIsNotInjected(t *testing.T) {
++ 	m, f := newAgentModel(t, info("a1", "explore", subagent.Done))
++ 	m.opts.Agent = newQuietAgent(t)
++ 	done := info("a1", "explore", subagent.Done)
++ 	done.Report = "found it in loop.go"
++ 	f.reports = []subagent.Info{done}
++ 	// It is held back while the prompt has text in it — which is where the
++ 	// parent's own agent_wait call collects it.
++ 	typeIn(m, "hold on")
++ 	m.Update(evAgents{})
++ 	if len(m.pendingReports) != 1 {
++ 		t.Fatalf("the report was not held: %d pending", len(m.pendingReports))
++ 	}
++ 	f.unclaimable = map[string]bool{"a1": true}
++ 	m.Update(key("backspace"))
++ 	typeIn(m, "")
++ 	for i := 0; i < 7; i++ {
++ 		m.Update(key("backspace"))
++ 	}
++ 	if len(m.pendingReports) != 0 {
++ 		t.Errorf("%d reports are still queued", len(m.pendingReports))
++ 	}
++ 	if n := len(m.opts.Agent.State().History()); n != 0 {
++ 		t.Errorf("the conversation got %d messages for a report the model already had", n)
++ 	}
++ 	if m.phase != phaseIdle {
++ 		t.Error("a turn was started to hand over a report the model already had")
++ 	}
++ }
++ // The same path when nobody else has taken it: the report goes up.
++ func TestAnUnclaimedReportIsStillInjected(t *testing.T) {
++ 	m, f := newAgentModel(t, info("a1", "explore", subagent.Done))
++ 	m.opts.Agent = newQuietAgent(t)
++ 	done := info("a1", "explore", subagent.Done)
++ 	done.Report = "found it in loop.go"
++ 	f.reports = []subagent.Info{done}
++ 	m.Update(evAgents{})
++ 	if len(m.pendingReports) != 0 {
++ 		t.Errorf("the report was not delivered: %d pending", len(m.pendingReports))
++ 	}
++ 	history := m.opts.Agent.State().History()
++ 	if len(history) != 1 || !strings.Contains(history[0].Content[0].Text, "found it in loop.go") {
++ 		t.Errorf("the conversation did not get the report: %+v", history)
++ 	}
++ }
++ // The thread header is where an agent's settings are legible — the row has no
++ // space for them — so it names the effort the agent is actually running at.
++ func TestTheThreadHeaderNamesTheEffort(t *testing.T) {
++ 	low := info("a1", "explore", subagent.Running)
++ 	low.Effort = "low"
++ 	plain := info("a2", "plan", subagent.Running)
++ 	m, _ := newAgentModel(t, low, plain)
++ 	m.Update(key("ctrl+b"))
++ 	m.Update(key("enter"))
++ 	if got := m.agentHeader(80); !strings.Contains(got, "low") {
++ 		t.Errorf("a1's header does not say what effort it runs at: %q", got)
++ 	}
++ 	m.Update(key("down"))
++ 	if got := m.agentHeader(80); strings.Contains(got, "effort") {
++ 		t.Errorf("a2's header invents an effort level: %q", got)
++ 	}
++ }
++ // The pane owns the keyboard while it has focus, which is what makes k a kill
++ // rather than a letter — but the prompt has to be reachable without closing
++ // it. Clicking the prompt is how you get back to typing.
++ func TestClickingThePromptTakesFocusFromTheSidebar(t *testing.T) {
++ 	m, _ := newAgentModel(t, info("a1", "explore", subagent.Running))
++ 	m.Update(key("ctrl+b"))
++ 	typeIn(m, "no")
++ 	if m.input.Value() != "" {
++ 		t.Fatalf("the prompt took %q while the pane had focus", m.input.Value())
++ 	}
++ 	// A click anywhere in the main column — the prompt box included — is a
++ 	// click on the conversation, and that is where typing should go.
++ 	m.View()
++ 	m.Update(click(4, m.height-4))
++ 	if !m.bar.open {
++ 		t.Error("clicking the prompt closed the sidebar; it should only move focus")
++ 	}
++ 	typeIn(m, "hello")
++ 	if got := m.input.Value(); got != "hello" {
++ 		t.Errorf("the prompt has %q after being clicked", got)
++ 	}
++ }
++ // And clicking back into the pane gives it the keys again.
++ func TestClickingTheSidebarTakesFocusBack(t *testing.T) {
++ 	m, f := newAgentModel(t, info("a1", "explore", subagent.Running))
++ 	m.Update(key("ctrl+b"))
++ 	m.View()
++ 	m.Update(click(4, m.height-4)) // to the prompt
++ 	m.View()
++ 	x := m.width - sidebarWidth + 2
++ 	m.Update(click(x, m.bar.hits[0].y0))
++ 	press(t, m, key("p"))
++ 	if len(f.acted) != 1 || f.acted[0] != "pause a1" {
++ 		t.Errorf("p did not reach the pane after clicking it: %v", f.acted)
++ 	}
++ 	if m.input.Value() != "" {
++ 		t.Errorf("the prompt took the keystroke too: %q", m.input.Value())
++ 	}
++ }
++ // ctrl+b on a pane that is open but not focused takes you to it rather than
++ // closing it: the pane is right there, and closing what you are looking at is
++ // never what that key was for.
++ func TestCtrlBFocusesAnOpenPaneBeforeClosingIt(t *testing.T) {
++ 	m, _ := newAgentModel(t, info("a1", "explore", subagent.Running))
++ 	m.Update(key("ctrl+b")) // open, focused
++ 	m.View()
++ 	m.Update(click(4, m.height-4)) // focus the prompt
++ 	if !m.bar.open || m.bar.focused {
++ 		t.Fatalf("after clicking the prompt: open=%v focused=%v", m.bar.open, m.bar.focused)
++ 	}
++ 	m.Update(key("ctrl+b"))
++ 	if !m.bar.open || !m.bar.focused {
++ 		t.Errorf("ctrl+b on an unfocused pane gave open=%v focused=%v", m.bar.open, m.bar.focused)
++ 	}
++ 	m.Update(key("ctrl+b"))
++ 	if m.bar.open {
++ 		t.Error("ctrl+b on a focused pane did not close it")
++ 	}
++ }
++ // Which pane has the keys has to be visible, or the next keystroke is a guess.
++ func TestTheScreenSaysWhichPaneHasTheKeys(t *testing.T) {
++ 	m, _ := newAgentModel(t, info("a1", "explore", subagent.Running))
++ 	m.Update(key("ctrl+b"))
++ 	focused := m.View()
++ 	if !strings.Contains(focused, "esc back") {
++ 		t.Errorf("a focused pane does not offer its keys:\n%s", focused)
++ 	}
++ 	m.View()
++ 	m.Update(click(4, m.height-4))
++ 	unfocused := m.View()
++ 	if !strings.Contains(unfocused, "ctrl+b") {
++ 		t.Errorf("an unfocused pane does not say how to get back to it:\n%s", unfocused)
++ 	}
++ 	if strings.Contains(unfocused, "p pause") {
++ 		t.Errorf("an unfocused pane still offers keys it will not answer:\n%s", unfocused)
++ 	}
++ }
++ // A turn ending puts the keyboard back in the prompt — unless the pane has it,
++ // in which case taking it away mid-keystroke would be the bug this focus
++ // separation exists to avoid.
++ func TestATurnEndingDoesNotStealFocusFromThePane(t *testing.T) {
++ 	m, _ := newAgentModel(t, info("a1", "explore", subagent.Running))
++ 	m.opts.SessionDir = t.TempDir()
++ 	m.Update(key("ctrl+b"))
++ 	m.phase = phaseRunning
++ 	m.Update(turnDone{})
++ 	if !m.bar.focused {
++ 		t.Fatal("the pane lost focus when a turn ended")
++ 	}
++ 	typeIn(m, "no")
++ 	if got := m.input.Value(); got != "" {
++ 		t.Errorf("the prompt took %q after the turn ended", got)
++ 	}
++ }

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

@@ -72,6 +72,11 @@ var (
72	72	styBoxFocus lipgloss.Style
73	73	styBoxBlur lipgloss.Style
74	74
	75	+ // The agents pane hangs off the right-hand edge, divided from the
	76	+ // transcript by a rule rather than boxed in: a full border beside a
	77	+ // transcript reads as a second window.
	78	+ styBar lipgloss.Style
	79	+
75	80	// The approval box is the one place the UI is allowed to shout: it is the
76	81	// only moment a human has to decide something.
77	82	styModal lipgloss.Style

+105−12internal/tui/testdata/mockapi/main.goView File

@@ -12,6 +12,11 @@
12	12	// tool_result comes back it streams a closing sentence and stops. That covers
13	13	// streaming, tool rendering, approve, deny, and interrupt.
14	14	//
	15	+ // With -spawn the script changes: the first turn asks for two subagents
	16	+ // instead of a shell command, and every request carrying a subagent's system
	17	+ // prompt is answered as that subagent — a short report, after a pause long
	18	+ // enough to watch the sidebar fill in.
	19	+ //
15	20	// Flags: -addr to move it, -fail to make the command exit non-zero, -slow to
16	21	// stretch the stream out for watching the spinner and ctrl-c.
17	22	package main
@@ -24,28 +29,65 @@ import (
24	29	"log"
25	30	"net/http"
26	31	"strings"
	32	+ "sync"
27	33	"time"
28	34	)
29	35
30	36	var (
31		- addr = flag.String("addr", "127.0.0.1:8899", "listen address")
32		- slow = flag.Duration("slow", 0, "pause between streamed words, e.g. 150ms")
33		- cmd = flag.String("cmd", "git status --short && go build ./...", "command the model asks to run")
	37	+ addr = flag.String("addr", "127.0.0.1:8899", "listen address")
	38	+ slow = flag.Duration("slow", 0, "pause between streamed words, e.g. 150ms")
	39	+ cmd = flag.String("cmd", "git status --short && go build ./...", "command the model asks to run")
	40	+ spawn = flag.Bool("spawn", false, "ask for two subagents on the first turn instead of a shell command")
	41	+ work = flag.Duration("work", 4*time.Second, "how long a subagent takes to answer, with -spawn")
34	42	)
35	43
	44	+ // listedOnce keeps the model-listing note to one line however many turns run.
	45	+ var listedOnce sync.Once
	46	+
36	47	func main() {
37	48	flag.Parse()
38	49	http.HandleFunc("/v1/messages", handle)
	50	+ http.HandleFunc("/v1/models", models)
39	51	log.Printf("mock Messages API on http://%s", *addr)
40	52	log.Fatal(http.ListenAndServe(*addr, nil))
41	53	}
42	54
	55	+ // models answers GET /v1/models, which the model picker opens on and which the
	56	+ // harness reads at startup to tell the agent what it may put a subagent on.
	57	+ func models(w http.ResponseWriter, r *http.Request) {
	58	+ w.Header().Set("Content-Type", "application/json")
	59	+ json.NewEncoder(w).Encode(map[string]any{
	60	+ "data": []map[string]any{
	61	+ {"id": "claude-fable-5-1", "display_name": "Claude Fable 5.1", "created_at": "2026-06-01T00:00:00Z", "max_input_tokens": 1000000},
	62	+ {"id": "claude-opus-5", "display_name": "Claude Opus 5", "created_at": "2026-04-01T00:00:00Z", "max_input_tokens": 1000000},
	63	+ {"id": "claude-sonnet-5", "display_name": "Claude Sonnet 5", "created_at": "2026-02-01T00:00:00Z", "max_input_tokens": 1000000},
	64	+ {"id": "claude-haiku-4-5", "display_name": "Claude Haiku 4.5", "created_at": "2025-10-01T00:00:00Z", "max_input_tokens": 200000},
	65	+ },
	66	+ "has_more": false,
	67	+ })
	68	+ }
	69	+
43	70	func handle(w http.ResponseWriter, r *http.Request) {
44	71	body, _ := io.ReadAll(r.Body)
45	72	// A tool_result in the history means the harness ran (or refused) our
46	73	// command and fed the outcome back, so the next turn is the last one.
47	74	final := strings.Contains(string(body), "tool_result")
48	75
	76	+ // Say once whether the agent was actually told what it may spawn on: the
	77	+ // listing is assembled at startup and nothing else makes it visible.
	78	+ if strings.Contains(string(body), "Models this endpoint serves") {
	79	+ listedOnce.Do(func() { log.Print("the agent's system prompt carries the model listing") })
	80	+ }
	81	+
	82	+ // A subagent announces itself in its system prompt. It gets one turn: a
	83	+ // report, after a pause long enough to see it working in the sidebar.
	84	+ if strings.Contains(string(body), "You are a subagent") {
	85	+ time.Sleep(*work)
	86	+ answer(w, "Found it: the policy is consulted in internal/agent/loop.go:281, "+
	87	+ "through Agent.authorizedExecute.")
	88	+ return
	89	+ }
	90	+
49	91	w.Header().Set("Content-Type", "text/event-stream")
50	92	w.WriteHeader(http.StatusOK)
51	93
@@ -61,6 +103,9 @@ func handle(w http.ResponseWriter, r *http.Request) {
61	103	if final {
62	104	text = "That is everything I can tell from here."
63	105	}
	106	+ if *spawn && !final {
	107	+ text = "Two independent questions — I will farm them out."
	108	+ }
64	109	send(w, "content_block_start", map[string]any{
65	110	"type": "content_block_start", "index": 0,
66	111	"content_block": map[string]any{"type": "text", "text": ""},
@@ -75,18 +120,23 @@ func handle(w http.ResponseWriter, r *http.Request) {
75	120	send(w, "content_block_stop", map[string]any{"type": "content_block_stop", "index": 0})
76	121
77	122	stop := "end_turn"
78		- if !final {
	123	+ switch {
	124	+ case final:
	125	+ case *spawn:
79	126	stop = "tool_use"
80		- send(w, "content_block_start", map[string]any{
81		- "type": "content_block_start", "index": 1,
82		- "content_block": map[string]any{"type": "tool_use", "id": "toolu_1", "name": "bash"},
	127	+ // One on a model that takes no effort level and one that does, so a
	128	+ // run exercises both halves of the answer.
	129	+ toolCall(w, 1, "toolu_1", "spawn_agent", map[string]string{
	130	+ "preset": "explore", "task": "find where the approval policy is consulted",
	131	+ "model": "claude-haiku-4-5", "effort": "low",
83	132	})
84		- args, _ := json.Marshal(map[string]string{"command": *cmd})
85		- send(w, "content_block_delta", map[string]any{
86		- "type": "content_block_delta", "index": 1,
87		- "delta": map[string]any{"type": "input_json_delta", "partial_json": string(args)},
	133	+ toolCall(w, 2, "toolu_2", "spawn_agent", map[string]string{
	134	+ "preset": "plan", "task": "work out how subagent transcripts could survive a resume",
	135	+ "model": "claude-fable-5-1", "effort": "low",
88	136	})
89		- send(w, "content_block_stop", map[string]any{"type": "content_block_stop", "index": 1})
	137	+ default:
	138	+ stop = "tool_use"
	139	+ toolCall(w, 1, "toolu_1", "bash", map[string]string{"command": *cmd})
90	140	}
91	141
92	142	send(w, "message_delta", map[string]any{
@@ -97,6 +147,49 @@ func handle(w http.ResponseWriter, r *http.Request) {
97	147	send(w, "message_stop", map[string]any{"type": "message_stop"})
98	148	}
99	149
	150	+ // toolCall streams one tool_use block, arguments and all.
	151	+ func toolCall(w http.ResponseWriter, index int, id, name string, args map[string]string) {
	152	+ send(w, "content_block_start", map[string]any{
	153	+ "type": "content_block_start", "index": index,
	154	+ "content_block": map[string]any{"type": "tool_use", "id": id, "name": name},
	155	+ })
	156	+ raw, _ := json.Marshal(args)
	157	+ send(w, "content_block_delta", map[string]any{
	158	+ "type": "content_block_delta", "index": index,
	159	+ "delta": map[string]any{"type": "input_json_delta", "partial_json": string(raw)},
	160	+ })
	161	+ send(w, "content_block_stop", map[string]any{"type": "content_block_stop", "index": index})
	162	+ }
	163	+
	164	+ // answer streams a whole turn that is nothing but text, which is what a
	165	+ // subagent's report is.
	166	+ func answer(w http.ResponseWriter, text string) {
	167	+ w.Header().Set("Content-Type", "text/event-stream")
	168	+ w.WriteHeader(http.StatusOK)
	169	+ send(w, "message_start", map[string]any{
	170	+ "type": "message_start",
	171	+ "message": map[string]any{
	172	+ "id": "msg_mock", "model": "claude-haiku-4-5",
	173	+ "usage": map[string]any{"input_tokens": 900},
	174	+ },
	175	+ })
	176	+ send(w, "content_block_start", map[string]any{
	177	+ "type": "content_block_start", "index": 0,
	178	+ "content_block": map[string]any{"type": "text", "text": ""},
	179	+ })
	180	+ send(w, "content_block_delta", map[string]any{
	181	+ "type": "content_block_delta", "index": 0,
	182	+ "delta": map[string]any{"type": "text_delta", "text": text},
	183	+ })
	184	+ send(w, "content_block_stop", map[string]any{"type": "content_block_stop", "index": 0})
	185	+ send(w, "message_delta", map[string]any{
	186	+ "type": "message_delta",
	187	+ "delta": map[string]any{"stop_reason": "end_turn"},
	188	+ "usage": map[string]any{"output_tokens": 60},
	189	+ })
	190	+ send(w, "message_stop", map[string]any{"type": "message_stop"})
	191	+ }
	192	+
100	193	func send(w http.ResponseWriter, event string, data any) {
101	194	b, _ := json.Marshal(data)
102	195	fmt.Fprintf(w, "event: %s\ndata: %s\n\n", event, b)

+5−0internal/tui/theme.goView File

@@ -178,6 +178,11 @@ func applyTheme(name string) {
178	178	BorderForeground(colFaint).
179	179	Padding(0, 1)
180	180
	181	+ styBar = lipgloss.NewStyle().
	182	+ Border(lipgloss.NormalBorder(), false, false, false, true).
	183	+ BorderForeground(colFaint).
	184	+ Padding(0, 1)
	185	+
181	186	styModal = lipgloss.NewStyle().
182	187	Border(lipgloss.RoundedBorder()).
183	188	BorderForeground(colCoral).