johannSoCodeyPublic

tui: /skills, and /<slug> as a user turn

Add a Skills field to the TUI's Options, a /skills command that lists
discovered skills, and an isSkill guard so a recognised /<slug> falls
through to the ordinary user-turn path instead of being rejected as an
unknown command. An unrecognised slash still errors as before.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

Browse Files

Jjonicommitted 4 weeks ago1 parent ab6fdfacommit62ffa3e

Showing 12 changed files with 2922 additions and 0 deletions.

+100−0internal/tui/bridge.goaddedView File

++ package tui
++ import (
++ 	"context"
++ 	tea "github.com/charmbracelet/bubbletea"
++ 	"harness/internal/agent"
++ 	"harness/internal/approval"
++ 	"harness/internal/llm"
++ )
++ // The agent loop runs on its own goroutine and must not know a UI exists. It
++ // reaches the model through two one-way hatches:
++ //
++ //   - events go out through Program.Send, which is safe from any goroutine;
++ //   - approvals go out the same way and then block the agent on a reply
++ //     channel until the user presses a key.
++ //
++ // Blocking the agent goroutine is the correct behaviour, not a compromise: the
++ // tool must not run until a human says so. The Bubble Tea update loop keeps
++ // running throughout, so the UI stays responsive while the agent waits.
++ // sender is the part of tea.Program the bridge needs, narrowed to an interface
++ // so tests can drive it without starting a terminal program.
++ type sender interface{ Send(tea.Msg) }
++ // Event messages delivered into the Bubble Tea loop.
++ type (
++ 	evTurnStart  struct{ turn int }
++ 	evTextDelta  struct{ text string }
++ 	evText       struct{ text string }
++ 	evToolStart  struct{ tool, input string }
++ 	evToolResult struct {
++ 		tool, result string
++ 		isError      bool
++ 	}
++ 	evUsage   struct{ usage llm.Usage }
++ 	evCompact struct{}
++ 	// approvalMsg asks the user to decide. reply is buffered, so answering
++ 	// never blocks the UI even if the agent's context was cancelled first.
++ 	approvalMsg struct {
++ 		req   approval.Request
++ 		reply chan<- approval.Decision
++ 	}
++ 	// turnDone reports the end of one prompt, with whatever the run returned.
++ 	turnDone struct {
++ 		err   error
++ 		usage llm.Usage
++ 		turns int
++ 	}
++ )
++ // bridge adapts the agent's callbacks to Bubble Tea messages.
++ type bridge struct{ p sender }
++ // Observe is the agent.Observe callback. It is called from the agent
++ // goroutine; Send is safe there.
++ func (b *bridge) Observe(ev agent.Event) {
++ 	switch ev.Kind {
++ 	case agent.EventTurnStart:
++ 		b.p.Send(evTurnStart{turn: ev.Turn})
++ 	case agent.EventTextDelta:
++ 		b.p.Send(evTextDelta{text: ev.Text})
++ 	case agent.EventText:
++ 		b.p.Send(evText{text: ev.Text})
++ 	case agent.EventToolStart:
++ 		b.p.Send(evToolStart{tool: ev.Tool, input: summarizeInput(ev.Input)})
++ 	case agent.EventToolResult:
++ 		b.p.Send(evToolResult{tool: ev.Tool, result: ev.Result, isError: ev.IsError})
++ 	case agent.EventUsage:
++ 		b.p.Send(evUsage{usage: ev.Usage})
++ 	case agent.EventCompact:
++ 		b.p.Send(evCompact{})
++ 	}
++ }
++ // Prompt implements approval.Prompt. It hands the request to the UI and waits.
++ //
++ // The context is honoured while waiting, so ctrl-c during an approval prompt
++ // interrupts the turn instead of stranding the agent on a channel nobody will
++ // ever read.
++ func (b *bridge) Prompt(ctx context.Context, req approval.Request) (approval.Decision, error) {
++ 	if err := ctx.Err(); err != nil {
++ 		return approval.Deny, err
++ 	}
++ 	reply := make(chan approval.Decision, 1)
++ 	b.p.Send(approvalMsg{req: req, reply: reply})
++ 	select {
++ 	case d := <-reply:
++ 		return d, nil
++ 	case <-ctx.Done():
++ 		// Denying on cancellation is the only safe reading: the turn is going
++ 		// away and nobody approved anything.
++ 		return approval.Deny, ctx.Err()
++ 	}
++ }

+179−0internal/tui/bridge_test.goaddedView File

++ package tui
++ import (
++ 	"context"
++ 	"encoding/json"
++ 	"sync"
++ 	"testing"
++ 	"time"
++ 	tea "github.com/charmbracelet/bubbletea"
++ 	"harness/internal/agent"
++ 	"harness/internal/approval"
++ )
++ // recorder stands in for tea.Program: it captures what the bridge sends
++ // without needing a terminal.
++ type recorder struct {
++ 	mu   sync.Mutex
++ 	msgs []tea.Msg
++ 	// onSend runs for each message, so a test can answer an approval from the
++ 	// "UI side" the way the Update loop would.
++ 	onSend func(tea.Msg)
++ }
++ func (r *recorder) Send(m tea.Msg) {
++ 	r.mu.Lock()
++ 	r.msgs = append(r.msgs, m)
++ 	f := r.onSend
++ 	r.mu.Unlock()
++ 	if f != nil {
++ 		f(m)
++ 	}
++ }
++ func (r *recorder) all() []tea.Msg {
++ 	r.mu.Lock()
++ 	defer r.mu.Unlock()
++ 	return append([]tea.Msg(nil), r.msgs...)
++ }
++ func TestObserveTranslatesEvents(t *testing.T) {
++ 	r := &recorder{}
++ 	b := &bridge{p: r}
++ 	b.Observe(agent.Event{Kind: agent.EventTurnStart, Turn: 2})
++ 	b.Observe(agent.Event{Kind: agent.EventTextDelta, Text: "hi"})
++ 	b.Observe(agent.Event{Kind: agent.EventToolStart, Tool: "grep", Input: json.RawMessage(`{"pattern":"x"}`)})
++ 	b.Observe(agent.Event{Kind: agent.EventToolResult, Tool: "grep", Result: "x.go:1", IsError: false})
++ 	b.Observe(agent.Event{Kind: agent.EventCompact})
++ 	msgs := r.all()
++ 	if len(msgs) != 5 {
++ 		t.Fatalf("got %d messages, want 5", len(msgs))
++ 	}
++ 	if m, ok := msgs[0].(evTurnStart); !ok || m.turn != 2 {
++ 		t.Errorf("msgs[0] = %#v, want evTurnStart{2}", msgs[0])
++ 	}
++ 	if m, ok := msgs[2].(evToolStart); !ok || m.input != "pattern=x" {
++ 		t.Errorf("msgs[2] = %#v, want summarised tool input", msgs[2])
++ 	}
++ 	if _, ok := msgs[4].(evCompact); !ok {
++ 		t.Errorf("msgs[4] = %#v, want evCompact", msgs[4])
++ 	}
++ }
++ // The agent goroutine must block until the UI answers, and must get exactly
++ // the decision the user picked.
++ func TestPromptBlocksUntilAnswered(t *testing.T) {
++ 	r := &recorder{}
++ 	r.onSend = func(m tea.Msg) {
++ 		if am, ok := m.(approvalMsg); ok {
++ 			go func() {
++ 				time.Sleep(10 * time.Millisecond)
++ 				am.reply <- approval.AlwaysThisTool
++ 			}()
++ 		}
++ 	}
++ 	b := &bridge{p: r}
++ 	start := time.Now()
++ 	got, err := b.Prompt(context.Background(), approval.Request{Tool: "bash", Summary: "run a shell command"})
++ 	if err != nil {
++ 		t.Fatalf("Prompt: %v", err)
++ 	}
++ 	if got != approval.AlwaysThisTool {
++ 		t.Errorf("decision = %v, want AlwaysThisTool", got)
++ 	}
++ 	if time.Since(start) < 10*time.Millisecond {
++ 		t.Error("Prompt returned before the UI answered")
++ 	}
++ }
++ // A cancelled turn must not strand the agent on a channel no one will read.
++ // This is the deadlock the whole design has to avoid.
++ func TestPromptUnblocksOnCancel(t *testing.T) {
++ 	r := &recorder{} // never answers
++ 	b := &bridge{p: r}
++ 	ctx, cancel := context.WithCancel(context.Background())
++ 	go func() {
++ 		time.Sleep(10 * time.Millisecond)
++ 		cancel()
++ 	}()
++ 	done := make(chan struct{})
++ 	var got approval.Decision
++ 	var err error
++ 	go func() {
++ 		got, err = b.Prompt(ctx, approval.Request{Tool: "bash"})
++ 		close(done)
++ 	}()
++ 	select {
++ 	case <-done:
++ 	case <-time.After(2 * time.Second):
++ 		t.Fatal("Prompt did not return after its context was cancelled")
++ 	}
++ 	if got != approval.Deny {
++ 		t.Errorf("decision = %v, want Deny on cancellation", got)
++ 	}
++ 	if err == nil {
++ 		t.Error("want a non-nil error on cancellation")
++ 	}
++ }
++ func TestPromptRefusesAnAlreadyCancelledContext(t *testing.T) {
++ 	r := &recorder{}
++ 	b := &bridge{p: r}
++ 	ctx, cancel := context.WithCancel(context.Background())
++ 	cancel()
++ 	got, err := b.Prompt(ctx, approval.Request{Tool: "bash"})
++ 	if got != approval.Deny || err == nil {
++ 		t.Errorf("Prompt = (%v, %v), want (Deny, error)", got, err)
++ 	}
++ 	if len(r.all()) != 0 {
++ 		t.Error("a cancelled prompt still bothered the UI")
++ 	}
++ }
++ // The reply channel is buffered, so a UI that answers a request whose agent
++ // has already given up must not block forever.
++ func TestReplyChannelNeverBlocksTheUI(t *testing.T) {
++ 	r := &recorder{}
++ 	b := &bridge{p: r}
++ 	ctx, cancel := context.WithCancel(context.Background())
++ 	var captured approvalMsg
++ 	got := make(chan struct{})
++ 	r.onSend = func(m tea.Msg) {
++ 		if am, ok := m.(approvalMsg); ok {
++ 			captured = am
++ 			close(got)
++ 		}
++ 	}
++ 	go b.Prompt(ctx, approval.Request{Tool: "bash"})
++ 	<-got
++ 	cancel()
++ 	time.Sleep(20 * time.Millisecond) // let Prompt give up
++ 	done := make(chan struct{})
++ 	go func() {
++ 		captured.reply <- approval.Once // must not block
++ 		close(done)
++ 	}()
++ 	select {
++ 	case <-done:
++ 	case <-time.After(time.Second):
++ 		t.Fatal("answering an abandoned approval blocked the UI")
++ 	}
++ }
++ // The bridge must satisfy the interfaces the agent and policy expect. If these
++ // signatures drift, this stops compiling, which is the point.
++ var (
++ 	_ = func(b *bridge) { var _ func(agent.Event) = b.Observe }
++ 	_ = func(b *bridge) { var _ approval.Prompt = b.Prompt }
++ )

+106−0internal/tui/colour_test.goaddedView File

++ package tui
++ import (
++ 	"strings"
++ 	"testing"
++ 	"unicode/utf8"
++ 	"github.com/charmbracelet/lipgloss"
++ 	"github.com/muesli/termenv"
++ 	"harness/internal/llm"
++ )
++ // forceColour makes styles emit real escape sequences. Without it the test
++ // renderer detects no terminal, strips every colour, and any assertion about
++ // what a style actually painted passes vacuously.
++ func forceColour(t *testing.T) {
++ 	t.Helper()
++ 	prev := lipgloss.ColorProfile()
++ 	lipgloss.SetColorProfile(termenv.TrueColor)
++ 	t.Cleanup(func() { lipgloss.SetColorProfile(prev) })
++ }
++ // unbackedCells returns the printable characters that were emitted with no
++ // background colour in force.
++ func unbackedCells(s string) string {
++ 	var out []rune
++ 	active := ""
++ 	for i := 0; i < len(s); {
++ 		if s[i] == 0x1b && i+1 < len(s) && s[i+1] == '[' {
++ 			j := i + 2
++ 			for j < len(s) && s[j] != 'm' {
++ 				j++
++ 			}
++ 			if j >= len(s) {
++ 				break
++ 			}
++ 			if p := s[i+2 : j]; p == "" || p == "0" {
++ 				active = ""
++ 			} else {
++ 				active = p
++ 			}
++ 			i = j + 1
++ 			continue
++ 		}
++ 		r, size := utf8.DecodeRuneInString(s[i:])
++ 		if !strings.Contains(active, "48;") {
++ 			out = append(out, r)
++ 		}
++ 		i += size
++ 	}
++ 	return string(out)
++ }
++ // A style nested inside a background ends with a reset, which drops the
++ // background for everything after it and tears a visible hole in the pill.
++ func TestPillsAreFilledEdgeToEdge(t *testing.T) {
++ 	forceColour(t)
++ 	m := newTestModel(t)
++ 	m.opts.ContextWindow = 200_000
++ 	m.Update(evUsage{usage: llm.Usage{InputTokens: 2_000, CacheReadInputTokens: 18_000}})
++ 	pill, ok := m.contextPill()
++ 	if !ok {
++ 		t.Fatal("no context pill after usage was reported")
++ 	}
++ 	if got := unbackedCells(pill); got != "" {
++ 		t.Errorf("context pill has unfilled cells %q in %q", got, pill)
++ 	}
++ 	if got := unbackedCells(styName.Render(username())); got != "" {
++ 		t.Errorf("name pill has unfilled cells %q", got)
++ 	}
++ }
++ func TestContextPillColoursByPressure(t *testing.T) {
++ 	forceColour(t)
++ 	cases := []struct {
++ 		tokens int
++ 		pct    string
++ 		colour lipgloss.AdaptiveColor
++ 	}{
++ 		{10_000, "(10%)", colOK},
++ 		{65_000, "(65%)", colWarn},
++ 		{90_000, "(90%)", colErr},
++ 	}
++ 	for _, tc := range cases {
++ 		m := newTestModel(t)
++ 		m.opts.ContextWindow = 100_000
++ 		m.Update(evUsage{usage: llm.Usage{InputTokens: tc.tokens}})
++ 		pill, ok := m.contextPill()
++ 		if !ok {
++ 			t.Fatalf("%d tokens produced no pill", tc.tokens)
++ 		}
++ 		if !strings.Contains(pill, tc.pct) {
++ 			t.Errorf("%d tokens: %q does not report %s", tc.tokens, pill, tc.pct)
++ 		}
++ 		want := termenv.TrueColor.Color(tc.colour.Dark).Sequence(false)
++ 		if !strings.Contains(pill, want) {
++ 			t.Errorf("%d tokens: pill is not %s: %q", tc.tokens, tc.colour.Dark, pill)
++ 		}
++ 	}
++ }

+139−0internal/tui/format.goaddedView File

++ package tui
++ import (
++ 	"fmt"
++ 	"net/url"
++ 	"os"
++ 	"strings"
++ 	"unicode"
++ 	"harness/internal/llm"
++ )
++ // human renders a token count the way a status bar wants to read it.
++ func human(n int) string {
++ 	switch {
++ 	case n >= 1_000_000:
++ 		return fmt.Sprintf("%.1fM", float64(n)/1e6)
++ 	case n >= 1_000:
++ 		return fmt.Sprintf("%.1fk", float64(n)/1e3)
++ 	}
++ 	return fmt.Sprint(n)
++ }
++ // prettyModel turns an API model id into the name a person uses for it:
++ // claude-opus-5 becomes "Opus 5", claude-haiku-4-5-20251001 becomes
++ // "Haiku 4.5". An id that does not fit the shape is returned unchanged, which
++ // matters because this also runs against gateways serving models we have
++ // never heard of.
++ func prettyModel(id string) string {
++ 	s := strings.TrimSuffix(strings.TrimPrefix(id, "claude-"), "-latest")
++ 	// Anything bracketed is a variant tag, not part of the name: opus-5[1m].
++ 	tag := ""
++ 	if i := strings.IndexByte(s, '['); i >= 0 {
++ 		tag, s = s[i:], s[:i]
++ 	}
++ 	parts := strings.Split(s, "-")
++ 	if len(parts) < 2 {
++ 		return id
++ 	}
++ 	// A trailing eight-digit date stamp is a build, not a version.
++ 	if last := parts[len(parts)-1]; len(last) == 8 && allDigits(last) {
++ 		parts = parts[:len(parts)-1]
++ 	}
++ 	family, rest := parts[0], parts[1:]
++ 	if family == "" || !isAlpha(family) {
++ 		return id
++ 	}
++ 	name := strings.ToUpper(family[:1]) + family[1:]
++ 	var version []string
++ 	for _, p := range rest {
++ 		if !allDigits(p) {
++ 			return id
++ 		}
++ 		version = append(version, p)
++ 	}
++ 	if len(version) > 0 {
++ 		name += " " + strings.Join(version, ".")
++ 	}
++ 	return name + tag
++ }
++ // endpointLabel names where the prompts are going. The default endpoint gets
++ // a short name; anything else shows its host, because "somewhere that is not
++ // Anthropic" is the single most important thing the header can say.
++ func endpointLabel(c *llm.Client) string {
++ 	if c == nil {
++ 		return ""
++ 	}
++ 	if c.IsDefaultEndpoint() {
++ 		return "anthropic"
++ 	}
++ 	if u, err := url.Parse(c.BaseURL); err == nil && u.Host != "" {
++ 		return u.Host
++ 	}
++ 	return c.BaseURL
++ }
++ // camel renders a snake_case tool name as the transcript shows it: read_file
++ // becomes ReadFile. It is a display transform only — approvals and errors
++ // still quote the real name.
++ func camel(name string) string {
++ 	parts := strings.Split(name, "_")
++ 	for i, p := range parts {
++ 		if p == "" {
++ 			continue
++ 		}
++ 		parts[i] = strings.ToUpper(p[:1]) + p[1:]
++ 	}
++ 	return strings.Join(parts, "")
++ }
++ func allDigits(s string) bool {
++ 	if s == "" {
++ 		return false
++ 	}
++ 	for _, r := range s {
++ 		if !unicode.IsDigit(r) {
++ 			return false
++ 		}
++ 	}
++ 	return true
++ }
++ func isAlpha(s string) bool {
++ 	for _, r := range s {
++ 		if !unicode.IsLetter(r) {
++ 			return false
++ 		}
++ 	}
++ 	return s != ""
++ }
++ func maxInt(a, b int) int {
++ 	if a > b {
++ 		return a
++ 	}
++ 	return b
++ }
++ func minInt(a, b int) int {
++ 	if a < b {
++ 		return a
++ 	}
++ 	return b
++ }
++ // shortenHome writes a path the way a person says it. The working root is
++ // shown in the welcome block, where "~/Work/thing" carries the same
++ // information as the absolute path in a third of the columns.
++ func shortenHome(path string) string {
++ 	home, err := os.UserHomeDir()
++ 	if err != nil || home == "" || path == home {
++ 		return path
++ 	}
++ 	if strings.HasPrefix(path, home+string(os.PathSeparator)) {
++ 		return "~" + path[len(home):]
++ 	}
++ 	return path
++ }

+311−0internal/tui/look_test.goaddedView File

++ package tui
++ import (
++ 	"context"
++ 	"strings"
++ 	"testing"
++ 	tea "github.com/charmbracelet/bubbletea"
++ 	"github.com/charmbracelet/lipgloss"
++ 	"harness/internal/approval"
++ 	"harness/internal/llm"
++ )
++ func TestPrettyModel(t *testing.T) {
++ 	cases := map[string]string{
++ 		"claude-opus-5":             "Opus 5",
++ 		"claude-sonnet-5":           "Sonnet 5",
++ 		"claude-haiku-4-5-20251001": "Haiku 4.5",
++ 		"claude-opus-5[1m]":         "Opus 5[1m]",
++ 		"claude-sonnet-4-5-latest":  "Sonnet 4.5",
++ 		"gpt-4o":                    "gpt-4o", // not ours: left alone rather than mangled
++ 		"some/gateway/model":        "some/gateway/model",
++ 		"":                          "",
++ 	}
++ 	for in, want := range cases {
++ 		if got := prettyModel(in); got != want {
++ 			t.Errorf("prettyModel(%q) = %q, want %q", in, got, want)
++ 		}
++ 	}
++ }
++ // The welcome block is laid out in columns, so a terminal too narrow to hold
++ // both must drop the mascot rather than slice it into noise.
++ func TestSplashDropsMascotWhenNarrow(t *testing.T) {
++ 	o := Options{Client: llm.New(llm.WithAPIKey("x")), Root: "/tmp/repo", Version: "v0.6.0"}
++ 	wide := splash(o, 100)
++ 	if !strings.Contains(wide, mascot[2]) {
++ 		t.Error("mascot missing at a comfortable width")
++ 	}
++ 	if !strings.Contains(wide, "/tmp/repo") {
++ 		t.Error("root missing from the welcome block")
++ 	}
++ 	for _, line := range strings.Split(strings.TrimRight(wide, "\n"), "\n") {
++ 		if w := lipgloss.Width(line); w > 100 {
++ 			t.Errorf("welcome line is %d cells wide, over the 100 available: %q", w, line)
++ 		}
++ 	}
++ 	// A deeply nested working directory is a long line, not a narrow
++ 	// terminal: it gets truncated, and the mascot stays.
++ 	deep := Options{Client: o.Client, Version: o.Version,
++ 		Root: "/tmp/claude-1000/-home-joni-Work-GO-coding-harness/b520442d-29dd-4870/scratchpad/demo"}
++ 	if !strings.Contains(splash(deep, 100), mascot[2]) {
++ 		t.Error("a long root path dropped the mascot on a wide terminal")
++ 	}
++ 	narrow := splash(o, 24)
++ 	if strings.Contains(narrow, mascot[2]) {
++ 		t.Error("mascot survived into a terminal too narrow for it")
++ 	}
++ 	if !strings.Contains(narrow, "harness") {
++ 		t.Error("narrow welcome block lost its name")
++ 	}
++ }
++ func TestStatusShowsContextGauge(t *testing.T) {
++ 	m := newTestModel(t)
++ 	m.opts.ContextWindow = 200_000
++ 	m.Update(tea.WindowSizeMsg{Width: 120, Height: 30})
++ 	m.Update(evUsage{usage: llm.Usage{InputTokens: 2_000, CacheReadInputTokens: 18_000, OutputTokens: 500}})
++ 	status := m.status()
++ 	if !strings.Contains(status, "20.0k") {
++ 		t.Errorf("context size missing from the status bar: %q", status)
++ 	}
++ 	if !strings.Contains(status, "(10%)") {
++ 		t.Errorf("context percentage wrong or missing: %q", status)
++ 	}
++ 	// A second turn replaces the gauge rather than adding to it: the context
++ 	// is how much the model read this time, not the sum of every turn.
++ 	m.Update(evUsage{usage: llm.Usage{InputTokens: 1_000, CacheReadInputTokens: 3_000}})
++ 	if got := m.status(); !strings.Contains(got, "(2%)") {
++ 		t.Errorf("gauge accumulated across turns instead of replacing: %q", got)
++ 	}
++ }
++ func TestShiftTabCyclesApprovalMode(t *testing.T) {
++ 	m := newTestModel(t)
++ 	if strings.Contains(m.modeLine(), "accept-all") {
++ 		t.Fatal("started in accept-all without being asked to")
++ 	}
++ 	m.Update(key("shift+tab"))
++ 	if !m.opts.Policy.YOLO {
++ 		t.Error("shift+tab did not turn accept-all on")
++ 	}
++ 	if !strings.Contains(m.modeLine(), "accept-all on") {
++ 		t.Errorf("mode line does not report accept-all: %q", m.modeLine())
++ 	}
++ 	if !strings.Contains(m.tr.render(), "accept-all on") {
++ 		t.Error("a change to what the agent may do was not recorded in the transcript")
++ 	}
++ 	m.Update(key("shift+tab"))
++ 	if m.opts.Policy.YOLO {
++ 		t.Error("shift+tab did not turn accept-all back off")
++ 	}
++ }
++ func TestInputBoxGrowsWithContentAndStops(t *testing.T) {
++ 	m := newTestModel(t)
++ 	if got := m.input.Height(); got != 1 {
++ 		t.Errorf("empty prompt is %d lines tall, want 1", got)
++ 	}
++ 	m.input.SetValue("one\ntwo\nthree")
++ 	m.growInput()
++ 	if got := m.input.Height(); got != 3 {
++ 		t.Errorf("three lines of input gave a box %d tall", got)
++ 	}
++ 	m.input.SetValue(strings.Repeat("x\n", 40))
++ 	m.growInput()
++ 	if got := m.input.Height(); got != inputMaxLines {
++ 		t.Errorf("box grew to %d, want it capped at %d", got, inputMaxLines)
++ 	}
++ }
++ // The numbered options are the primary way to answer, so the number a person
++ // reads must reach the decision it is printed next to.
++ func TestApprovalNumbersMatchTheirLabels(t *testing.T) {
++ 	cases := []struct {
++ 		name         string
++ 		rememberable bool
++ 		want         map[string]approval.Decision
++ 	}{
++ 		{"rememberable", true, map[string]approval.Decision{
++ 			"1": approval.Once,
++ 			"2": approval.AlwaysThisCommand,
++ 			"3": approval.AlwaysThisTool,
++ 			"4": approval.Deny,
++ 		}},
++ 		{"opaque", false, map[string]approval.Decision{
++ 			"1": approval.Once,
++ 			"2": approval.AlwaysThisTool,
++ 			"3": approval.Deny,
++ 		}},
++ 	}
++ 	for _, tc := range cases {
++ 		t.Run(tc.name, func(t *testing.T) {
++ 			for k, want := range tc.want {
++ 				m := newTestModel(t)
++ 				req := approval.Request{Tool: "bash", Summary: "run it", Detail: "ls", Rememberable: tc.rememberable}
++ 				reply := pend(m, req)
++ 				view := m.approvalView()
++ 				opts := m.choices(req)
++ 				idx := int(k[0] - '1')
++ 				if !strings.Contains(view, opts[idx].label) {
++ 					t.Fatalf("option %s (%q) is not in the box:\n%s", k, opts[idx].label, view)
++ 				}
++ 				m.Update(key(k))
++ 				select {
++ 				case got := <-reply:
++ 					if got != want {
++ 						t.Errorf("key %s sent %v, want %v", k, got, want)
++ 					}
++ 				default:
++ 					t.Fatalf("key %s answered nothing", k)
++ 				}
++ 			}
++ 		})
++ 	}
++ }
++ // The chrome grows and shrinks — the prompt box with what is typed, the
++ // approval box when it appears — so the view has to stay exactly as tall as
++ // the terminal rather than pushing its own top off the screen.
++ func TestViewFillsExactlyTheTerminalHeight(t *testing.T) {
++ 	for _, size := range [][2]int{{80, 24}, {120, 40}, {60, 30}} {
++ 		m := newTestModel(t)
++ 		m.Update(tea.WindowSizeMsg{Width: size[0], Height: size[1]})
++ 		for i := 0; i < 40; i++ {
++ 			m.tr.addUser("a line of scrollback")
++ 		}
++ 		m.sync()
++ 		if got := lipgloss.Height(m.View()); got != size[1] {
++ 			t.Errorf("%dx%d: view is %d rows, want %d", size[0], size[1], got, size[1])
++ 		}
++ 		m.input.SetValue("one\ntwo\nthree\nfour")
++ 		m.growInput()
++ 		if got := lipgloss.Height(m.View()); got != size[1] {
++ 			t.Errorf("%dx%d with a grown prompt: view is %d rows, want %d", size[0], size[1], got, size[1])
++ 		}
++ 		pend(m, approval.Request{Tool: "bash", Summary: "run it", Detail: "rm -rf /", Rememberable: true})
++ 		if got := lipgloss.Height(m.View()); got != size[1] {
++ 			t.Errorf("%dx%d while approving: view is %d rows, want %d", size[0], size[1], got, size[1])
++ 		}
++ 	}
++ }
++ // Every line of chrome has to fit the terminal it is drawn in; a status bar
++ // one cell too wide wraps and silently eats a row of the transcript.
++ func TestChromeNeverExceedsTerminalWidth(t *testing.T) {
++ 	for _, w := range []int{40, 60, 80, 120} {
++ 		m := newTestModel(t)
++ 		m.opts.Effort = "high"
++ 		m.Update(tea.WindowSizeMsg{Width: w, Height: 24})
++ 		m.Update(evUsage{usage: llm.Usage{InputTokens: 24_000, CacheReadInputTokens: 180_000, OutputTokens: 4_200}})
++ 		m.phase = phaseRunning
++ 		for name, line := range map[string]string{
++ 			"activity": m.activity(),
++ 			"status":   m.status(),
++ 			"mode":     m.modeLine(),
++ 			"input":    m.inputBox(),
++ 		} {
++ 			for _, row := range strings.Split(line, "\n") {
++ 				if got := lipgloss.Width(row); got > w {
++ 					t.Errorf("width %d: %s line is %d cells: %q", w, name, got, row)
++ 				}
++ 			}
++ 		}
++ 	}
++ }
++ // A transcript entry the renderer does not know about must not vanish; the
++ // welcome block is passed through verbatim.
++ func TestRawEntryIsPassedThrough(t *testing.T) {
++ 	tr := newTranscript(80)
++ 	tr.addRaw("▐██████▌ verbatim\n")
++ 	if got := tr.render(); !strings.Contains(got, "▐██████▌ verbatim") {
++ 		t.Errorf("raw entry was rewritten: %q", got)
++ 	}
++ }
++ func TestCamelNamesTools(t *testing.T) {
++ 	for in, want := range map[string]string{
++ 		"read_file": "ReadFile",
++ 		"bash":      "Bash",
++ 		"edit_file": "EditFile",
++ 		"":          "",
++ 	} {
++ 		if got := camel(in); got != want {
++ 			t.Errorf("camel(%q) = %q, want %q", in, got, want)
++ 		}
++ 	}
++ }
++ func TestNewModelOpensWithTheWelcomeBlock(t *testing.T) {
++ 	m := newModel(context.Background(), Options{
++ 		Client: llm.New(llm.WithAPIKey("x")),
++ 		Root:   "/tmp/repo",
++ 		Policy: approval.New(nil),
++ 		Banner: []string{"resumed session abc"},
++ 	})
++ 	out := m.tr.render()
++ 	if !strings.Contains(out, "harness") {
++ 		t.Error("welcome block missing")
++ 	}
++ 	if i, j := strings.Index(out, "harness"), strings.Index(out, "resumed session abc"); i < 0 || j < 0 || i > j {
++ 		t.Error("the banner should follow the welcome block, not precede it")
++ 	}
++ }
++ func TestDiffStatCountsEditsNotHeaders(t *testing.T) {
++ 	diff := "--- a/x.go\n+++ b/x.go\n@@ -1,2 +1,4 @@\n ctx\n-gone\n+one\n+two\n+three\n"
++ 	if got, want := diffStat(strings.Split(diff, "\n")), "3 additions, 1 removal"; got != want {
++ 		t.Errorf("diffStat = %q, want %q", got, want)
++ 	}
++ 	// The +++/--- file headers look like edits and are not.
++ 	if got := diffStat([]string{"--- a/x.go", "+++ b/x.go"}); got != "0 additions, 0 removals" {
++ 		t.Errorf("file headers counted as edits: %q", got)
++ 	}
++ 	tr := newTranscript(80)
++ 	tr.startTool("edit_file", "path=x.go")
++ 	tr.finishTool("edit_file", diff, false)
++ 	if out := tr.render(); !strings.Contains(out, "3 additions, 1 removal") {
++ 		t.Errorf("diff rendered without its stat line:\n%s", out)
++ 	}
++ }
++ // Cache reads are the number this harness exists to move, so they belong on
++ // the status bar rather than only in the metrics file.
++ func TestStatusReportsCacheReadsSeparately(t *testing.T) {
++ 	m := newTestModel(t)
++ 	m.Update(tea.WindowSizeMsg{Width: 120, Height: 30})
++ 	m.Update(evUsage{usage: llm.Usage{InputTokens: 4_200, CacheReadInputTokens: 58_000, OutputTokens: 1_340}})
++ 	status := m.status()
++ 	for _, want := range []string{"4.2k", "58.0k", "1.3k"} {
++ 		if !strings.Contains(status, want) {
++ 			t.Errorf("%s missing from the status bar: %q", want, status)
++ 		}
++ 	}
++ 	// With nothing cached there is no cache field to read past.
++ 	m2 := newTestModel(t)
++ 	m2.Update(evUsage{usage: llm.Usage{InputTokens: 900, OutputTokens: 100}})
++ 	if strings.Contains(m2.status(), "⟳") {
++ 		t.Errorf("empty cache field still drawn: %q", m2.status())
++ 	}
++ }

+787−0internal/tui/model.goaddedView File

++ package tui
++ import (
++ 	"context"
++ 	"errors"
++ 	"fmt"
++ 	"os"
++ 	"strings"
++ 	"time"
++ 	"github.com/charmbracelet/bubbles/spinner"
++ 	"github.com/charmbracelet/bubbles/textarea"
++ 	"github.com/charmbracelet/bubbles/viewport"
++ 	tea "github.com/charmbracelet/bubbletea"
++ 	"github.com/charmbracelet/lipgloss"
++ 	"harness/internal/agent"
++ 	"harness/internal/approval"
++ 	"harness/internal/llm"
++ 	"harness/internal/skills"
++ )
++ // Options wires the TUI to an already-built agent. The TUI owns no policy of
++ // its own: it renders what the agent reports and asks what the policy asks.
++ type Options struct {
++ 	Agent      *agent.Agent
++ 	Policy     *approval.Policy
++ 	Client     *llm.Client
++ 	Root       string
++ 	SessionDir string
++ 	SessionID  string
++ 	ToolNames  []string
++ 	Verbose    bool
++ 	YOLO       bool
++ 	// Version, Effort and ContextWindow are display only: they let the
++ 	// welcome block and the status bar report the run's shape rather than
++ 	// guess at it.
++ 	Version       string
++ 	Effort        string
++ 	ContextWindow int
++ 	// Banner is an optional first line of scrollback, used for things the CLI
++ 	// wants to say before the loop starts: a resumed session, a non-default
++ 	// endpoint.
++ 	Banner []string
++ 	// Skills are the instruction sets discovered at startup, used to resolve
++ 	// /<slug> and to answer /skills.
++ 	Skills []skills.Skill
++ }
++ type phase int
++ const (
++ 	phaseIdle phase = iota
++ 	phaseRunning
++ 	phaseApproving
++ )
++ // inputMaxLines caps how far the prompt box grows before it scrolls. Past
++ // about six lines the box is eating the transcript it exists to talk about.
++ const inputMaxLines = 6
++ type model struct {
++ 	opts   Options
++ 	bridge *bridge
++ 	vp    viewport.Model
++ 	input textarea.Model
++ 	spin  spinner.Model
++ 	tr    *transcript
++ 	phase  phase
++ 	width  int
++ 	height int
++ 	ready  bool
++ 	// Turn bookkeeping.
++ 	turn      int
++ 	started   time.Time
++ 	usage     llm.Usage
++ 	turns     int
++ 	lastCost  float64
++ 	costKnown bool
++ 	// ctxTokens is the last turn's input size — what the model actually read,
++ 	// which is the number the context gauge is about. It replaces itself each
++ 	// turn rather than accumulating, and compaction makes it drop.
++ 	ctxTokens int
++ 	// verbSeed varies the working verb per turn so two turns in a row do not
++ 	// open with the same word.
++ 	verbSeed int
++ 	// pending approvals. The agent blocks on one at a time, but a queue costs
++ 	// nothing and means a second request can never be dropped.
++ 	pending []approvalMsg
++ 	// ctx plumbing for the running turn.
++ 	parent context.Context
++ 	cancel context.CancelFunc
++ 	// interrupting records that the user asked to stop, so the status line can
++ 	// say so while the agent unwinds.
++ 	interrupting bool
++ 	quitting bool
++ 	err      error
++ }
++ // pulse is the spinner: a star opening and closing rather than a rotating
++ // bar, which reads as thought rather than as a progress bar that is lying
++ // about knowing how far along it is.
++ var pulse = spinner.Spinner{
++ 	Frames: []string{"✢", "✳", "∗", "✻", "✽", "✻", "∗", "✳"},
++ 	FPS:    time.Second / 8,
++ }
++ // verbs are what the status line calls the wait. They rotate so a long turn
++ // does not look frozen even when nothing is streaming.
++ var verbs = []string{
++ 	"Thinking", "Pondering", "Deliberating", "Noodling", "Percolating",
++ 	"Puzzling", "Wrangling", "Simmering", "Cogitating", "Tinkering",
++ 	"Untangling", "Ruminating",
++ }
++ // newModel builds the model. Construction lives here rather than inside Run so
++ // tests drive the same wiring the program does; a hand-built model with a
++ // zero-valued textarea panics on the first resize.
++ func newModel(ctx context.Context, opts Options) *model {
++ 	ta := textarea.New()
++ 	ta.Placeholder = "ask for a change, or /help"
++ 	ta.Prompt = "› "
++ 	ta.ShowLineNumbers = false
++ 	ta.CharLimit = 0
++ 	ta.SetHeight(1)
++ 	ta.FocusedStyle.CursorLine = lipgloss.NewStyle()
++ 	ta.FocusedStyle.Prompt = styCoral
++ 	ta.BlurredStyle.Prompt = styFaint
++ 	ta.FocusedStyle.Placeholder = styFaint
++ 	ta.BlurredStyle.Placeholder = styFaint
++ 	ta.Focus()
++ 	// Enter submits; the model handles it before the textarea sees it.
++ 	ta.KeyMap.InsertNewline.SetKeys("ctrl+j", "alt+enter")
++ 	sp := spinner.New()
++ 	sp.Spinner = pulse
++ 	sp.Style = styCoral
++ 	m := &model{
++ 		opts:   opts,
++ 		bridge: &bridge{},
++ 		input:  ta,
++ 		spin:   sp,
++ 		tr:     newTranscript(80),
++ 		parent: ctx,
++ 	}
++ 	m.tr.setVerbose(opts.Verbose)
++ 	m.tr.addRaw(splash(opts, 80))
++ 	for _, line := range opts.Banner {
++ 		m.tr.addNotice(line)
++ 	}
++ 	if opts.YOLO {
++ 		m.tr.addNotice("-yolo — no approval prompts. Use a throwaway clone or a container.")
++ 	}
++ 	return m
++ }
++ // Run starts the program and blocks until the user exits.
++ func Run(ctx context.Context, opts Options) error {
++ 	m := newModel(ctx, opts)
++ 	p := tea.NewProgram(m, tea.WithAltScreen(), tea.WithContext(ctx))
++ 	// The bridge can only learn the program after it exists; the agent does
++ 	// not touch it until the first turn starts, which is after Run.
++ 	m.bridge.p = p
++ 	opts.Agent.Observe = m.bridge.Observe
++ 	if opts.Policy != nil {
++ 		opts.Policy.Prompt = m.bridge.Prompt
++ 	}
++ 	final, err := p.Run()
++ 	if err != nil && !errors.Is(err, tea.ErrProgramKilled) && !errors.Is(err, context.Canceled) {
++ 		return err
++ 	}
++ 	if fm, ok := final.(*model); ok {
++ 		return fm.err
++ 	}
++ 	return nil
++ }
++ func (m *model) Init() tea.Cmd { return textarea.Blink }
++ // runTurn drives one prompt on its own goroutine. Events reach the UI through
++ // the bridge while this runs; the command's return value ends the turn.
++ func (m *model) runTurn(prompt string) tea.Cmd {
++ 	ctx, cancel := context.WithCancel(m.parent)
++ 	m.cancel = cancel
++ 	a := m.opts.Agent
++ 	return func() tea.Msg {
++ 		_, err := a.Run(ctx, prompt)
++ 		cancel()
++ 		if saveErr := a.Save(m.opts.SessionDir, m.opts.SessionID, m.opts.Root, m.opts.Client.Model); saveErr != nil && err == nil {
++ 			err = fmt.Errorf("saving session: %w", saveErr)
++ 		}
++ 		u, turns := a.State().Usage()
++ 		return turnDone{err: err, usage: u, turns: turns}
++ 	}
++ }
++ func (m *model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
++ 	switch msg := msg.(type) {
++ 	case tea.WindowSizeMsg:
++ 		return m, m.resize(msg.Width, msg.Height)
++ 	case tea.KeyMsg:
++ 		return m.onKey(msg)
++ 	case spinner.TickMsg:
++ 		if m.phase == phaseRunning {
++ 			var cmd tea.Cmd
++ 			m.spin, cmd = m.spin.Update(msg)
++ 			return m, cmd
++ 		}
++ 		return m, nil
++ 	// ---- agent events -------------------------------------------------
++ 	case evTurnStart:
++ 		m.turn = msg.turn
++ 		return m, nil
++ 	case evTextDelta:
++ 		m.tr.appendDelta(msg.text)
++ 		return m, m.sync()
++ 	case evText:
++ 		m.tr.add(entry{kind: entryAssistant, text: strings.TrimSpace(msg.text)})
++ 		return m, m.sync()
++ 	case evToolStart:
++ 		m.tr.startTool(msg.tool, msg.input)
++ 		return m, m.sync()
++ 	case evToolResult:
++ 		m.tr.finishTool(msg.tool, msg.result, msg.isError)
++ 		return m, m.sync()
++ 	case evUsage:
++ 		m.usage = addUsage(m.usage, msg.usage)
++ 		m.ctxTokens = msg.usage.InputTokens + msg.usage.CacheReadInputTokens + msg.usage.CacheCreationInputTokens
++ 		return m, nil
++ 	case evCompact:
++ 		m.tr.addNotice("compacted the conversation")
++ 		return m, m.sync()
++ 	case approvalMsg:
++ 		m.pending = append(m.pending, msg)
++ 		m.phase = phaseApproving
++ 		return m, m.sync()
++ 	case turnDone:
++ 		return m, m.finishTurn(msg)
++ 	}
++ 	return m, nil
++ }
++ func (m *model) resize(w, h int) tea.Cmd {
++ 	m.width, m.height = w, h
++ 	m.tr.setWidth(w)
++ 	m.input.SetWidth(m.innerWidth())
++ 	if !m.ready {
++ 		m.vp = viewport.New(w, maxInt(1, h-8))
++ 		m.ready = true
++ 	} else {
++ 		m.vp.Width = w
++ 	}
++ 	// The welcome block is laid out for a width, so it is re-rendered rather
++ 	// than wrapped: it is the one entry that owns its own lines.
++ 	if len(m.tr.entries) > 0 && m.tr.entries[0].kind == entryRaw {
++ 		m.tr.entries[0].text = splash(m.opts, w)
++ 		m.tr.dirty = true
++ 	}
++ 	m.vp.SetContent(m.tr.render())
++ 	m.vp.GotoBottom()
++ 	return nil
++ }
++ // sync re-renders the scrollback, keeping the view pinned to the bottom unless
++ // the user has scrolled up to read something.
++ func (m *model) sync() tea.Cmd {
++ 	if !m.ready {
++ 		return nil
++ 	}
++ 	atBottom := m.vp.AtBottom()
++ 	m.vp.SetContent(m.tr.render())
++ 	if atBottom {
++ 		m.vp.GotoBottom()
++ 	}
++ 	return nil
++ }
++ func (m *model) finishTurn(msg turnDone) tea.Cmd {
++ 	m.phase = phaseIdle
++ 	m.interrupting = false
++ 	m.usage, m.turns = msg.usage, msg.turns
++ 	m.lastCost, m.costKnown = msg.usage.Cost(m.opts.Client.Model)
++ 	m.tr.closeOpen()
++ 	// Any approval still outstanding belongs to a turn that no longer exists.
++ 	for _, p := range m.pending {
++ 		p.reply <- approval.Deny
++ 	}
++ 	m.pending = nil
++ 	switch {
++ 	case msg.err == nil:
++ 	case errors.Is(msg.err, context.Canceled):
++ 		m.tr.addNotice("interrupted — the session is intact; say what to do differently")
++ 	default:
++ 		m.tr.addError(msg.err.Error())
++ 	}
++ 	m.input.Focus()
++ 	return tea.Batch(m.sync(), textarea.Blink)
++ }
++ func (m *model) onKey(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
++ 	if m.phase == phaseApproving {
++ 		return m.onApprovalKey(msg)
++ 	}
++ 	switch msg.String() {
++ 	case "ctrl+c":
++ 		// While a turn runs, ctrl-c interrupts it and leaves the session
++ 		// intact. Idle, it exits.
++ 		if m.phase == phaseRunning {
++ 			return m, m.interrupt()
++ 		}
++ 		m.quitting = true
++ 		return m, tea.Quit
++ 	case "esc":
++ 		if m.phase == phaseRunning {
++ 			return m, m.interrupt()
++ 		}
++ 		return m, nil
++ 	case "ctrl+d":
++ 		m.quitting = true
++ 		return m, tea.Quit
++ 	case "ctrl+r":
++ 		m.tr.setVerbose(!m.tr.verbose)
++ 		state := "collapsed"
++ 		if m.tr.verbose {
++ 			state = "full"
++ 		}
++ 		m.tr.addNotice("tool output: " + state)
++ 		return m, m.sync()
++ 	case "shift+tab":
++ 		return m, m.cycleMode()
++ 	case "pgup", "pgdown", "shift+up", "shift+down", "ctrl+home", "ctrl+end":
++ 		var cmd tea.Cmd
++ 		m.vp, cmd = m.vp.Update(msg)
++ 		return m, cmd
++ 	case "enter":
++ 		if m.phase == phaseRunning {
++ 			return m, nil // the agent is busy; queueing input would be a lie
++ 		}
++ 		line := strings.TrimSpace(m.input.Value())
++ 		if line == "" {
++ 			return m, nil
++ 		}
++ 		m.input.Reset()
++ 		m.growInput()
++ 		return m.submit(line)
++ 	}
++ 	var cmd tea.Cmd
++ 	m.input, cmd = m.input.Update(msg)
++ 	m.growInput()
++ 	return m, cmd
++ }
++ func (m *model) interrupt() tea.Cmd {
++ 	if m.cancel != nil {
++ 		m.cancel()
++ 	}
++ 	m.interrupting = true
++ 	return nil
++ }
++ // cycleMode flips the approval policy between asking and accepting. It is the
++ // one control in the chrome that changes what the agent is allowed to do, so
++ // it says so in the transcript rather than only in the mode line.
++ func (m *model) cycleMode() tea.Cmd {
++ 	if m.opts.Policy == nil {
++ 		return nil
++ 	}
++ 	m.opts.Policy.YOLO = !m.opts.Policy.YOLO
++ 	if m.opts.Policy.YOLO {
++ 		m.tr.addNotice("accept-all on — tool calls run without asking. Use a throwaway clone or a container.")
++ 	} else {
++ 		m.tr.addNotice("accept-all off — you will be asked before anything is changed.")
++ 	}
++ 	return m.sync()
++ }
++ // growInput sizes the prompt box to what has been typed into it.
++ func (m *model) growInput() {
++ 	inner := m.innerWidth()
++ 	n := 0
++ 	for _, line := range strings.Split(m.input.Value(), "\n") {
++ 		w := lipgloss.Width(line) + 2 // the "› " prompt
++ 		rows := (w + inner - 1) / inner
++ 		n += maxInt(1, rows)
++ 	}
++ 	if h := minInt(maxInt(1, n), inputMaxLines); h != m.input.Height() {
++ 		m.input.SetHeight(h)
++ 	}
++ }
++ // submit handles slash commands locally and sends anything else to the agent.
++ func (m *model) submit(line string) (tea.Model, tea.Cmd) {
++ 	switch {
++ 	case line == "/exit", line == "/quit":
++ 		m.quitting = true
++ 		return m, tea.Quit
++ 	case line == "/help":
++ 		m.tr.addNotice(helpText)
++ 		return m, m.sync()
++ 	case line == "/clear":
++ 		m.tr.clear()
++ 		return m, m.sync()
++ 	case line == "/allowed":
++ 		allowed := m.opts.Policy.Remembered()
++ 		if len(allowed) == 0 {
++ 			m.tr.addNotice("nothing is permanently allowed this session")
++ 		} else {
++ 			m.tr.addNotice("always allowed:\n  " + strings.Join(allowed, "\n  "))
++ 		}
++ 		return m, m.sync()
++ 	case line == "/skills":
++ 		if len(m.opts.Skills) == 0 {
++ 			m.tr.addNotice("no skills found in ~/" + skills.Dirname + " or ./" + skills.Dirname)
++ 		} else {
++ 			var b strings.Builder
++ 			b.WriteString("skills:")
++ 			for _, s := range m.opts.Skills {
++ 				fmt.Fprintf(&b, "\n  /%s  (%s) — %s", s.Name, s.Source, s.Description)
++ 			}
++ 			m.tr.addNotice(b.String())
++ 		}
++ 		return m, m.sync()
++ 	case strings.HasPrefix(line, "/") && !m.isSkill(line):
++ 		m.tr.addError("unknown command " + line + " — /help lists them")
++ 		return m, m.sync()
++ 	}
++ 	m.tr.addUser(line)
++ 	m.phase = phaseRunning
++ 	m.turn = 0
++ 	m.started = time.Now()
++ 	m.verbSeed++
++ 	return m, tea.Batch(m.sync(), m.spin.Tick, m.runTurn(line))
++ }
++ // isSkill reports whether a slash command names a discovered skill. Matching
++ // here rather than sending every unrecognised slash to the model means a typo
++ // is caught by the harness instead of puzzled over by the agent.
++ func (m *model) isSkill(line string) bool {
++ 	name := strings.TrimPrefix(line, "/")
++ 	if i := strings.IndexAny(name, " \t"); i >= 0 {
++ 		name = name[:i]
++ 	}
++ 	for _, s := range m.opts.Skills {
++ 		if s.Name == name {
++ 			return true
++ 		}
++ 	}
++ 	return false
++ }
++ // ---- approvals ----------------------------------------------------------
++ // choice is one answer offered by the approval box. Numbering it here rather
++ // than in the renderer keeps the keys and the labels from drifting apart.
++ type choice struct {
++ 	label string
++ 	keys  []string
++ 	dec   approval.Decision
++ 	note  string
++ }
++ func (m *model) choices(req approval.Request) []choice {
++ 	out := []choice{{label: "Yes", keys: []string{"y", "enter"}, dec: approval.Once, note: "approved once"}}
++ 	if req.Rememberable {
++ 		out = append(out, choice{
++ 			label: "Yes, and always this exact one",
++ 			keys:  []string{"a"},
++ 			dec:   approval.AlwaysThisCommand,
++ 			note:  "always allowing this exact " + req.Tool + " this session",
++ 		})
++ 	}
++ 	out = append(out,
++ 		choice{
++ 			label: "Yes, and always this tool",
++ 			keys:  []string{"t"},
++ 			dec:   approval.AlwaysThisTool,
++ 			note:  "always allowing tool " + req.Tool + " this session",
++ 		},
++ 		choice{label: "No, tell it to do something else", keys: []string{"n", "esc"}, dec: approval.Deny, note: "denied"},
++ 	)
++ 	return out
++ }
++ func (m *model) onApprovalKey(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
++ 	if len(m.pending) == 0 {
++ 		m.phase = phaseRunning
++ 		return m, nil
++ 	}
++ 	req := m.pending[0]
++ 	key := msg.String()
++ 	// ctrl-c mid-prompt denies the call and cancels the turn.
++ 	if key == "ctrl+c" {
++ 		req.reply <- approval.Deny
++ 		m.pending = m.pending[1:]
++ 		m.phase = phaseRunning
++ 		return m, tea.Batch(m.interrupt(), m.sync())
++ 	}
++ 	// "always this exact one" is not offered for an opaque command, and
++ 	// pressing its key must explain that rather than silently doing nothing.
++ 	opts := m.choices(req.req)
++ 	if key == "a" && !req.req.Rememberable {
++ 		m.tr.addError("this one cannot be remembered: its text does not determine what it runs")
++ 		return m, m.sync()
++ 	}
++ 	for i, c := range opts {
++ 		if !matches(c.keys, key) && key != fmt.Sprint(i+1) {
++ 			continue
++ 		}
++ 		req.reply <- c.dec
++ 		m.pending = m.pending[1:]
++ 		if len(m.pending) == 0 {
++ 			m.phase = phaseRunning
++ 		}
++ 		// The decision belongs to the call it gated, not to whatever the
++ 		// transcript happens to end with once the result lands.
++ 		m.tr.annotateTool(req.req.Tool, c.note)
++ 		return m, tea.Batch(m.sync(), m.spin.Tick)
++ 	}
++ 	return m, nil
++ }
++ func matches(keys []string, key string) bool {
++ 	for _, k := range keys {
++ 		if k == key {
++ 			return true
++ 		}
++ 	}
++ 	return false
++ }
++ // ---- view ---------------------------------------------------------------
++ const helpText = `commands: /allowed  /clear  /help  /skills  /exit
++ keys: enter send · ctrl+j newline · shift+tab cycle approval mode
++       ctrl+r toggle full tool output · pgup/pgdn scroll
++       esc or ctrl+c interrupt a turn · ctrl+c again to exit`
++ func (m *model) View() string {
++ 	if !m.ready {
++ 		return "starting…"
++ 	}
++ 	if m.quitting {
++ 		return ""
++ 	}
++ 	// The bottom chrome changes height — the prompt box grows, the approval
++ 	// box is taller than either — so the viewport is sized against what was
++ 	// actually rendered rather than against an assumed number of rows.
++ 	bottom := m.bottom()
++ 	if h := maxInt(1, m.height-lipgloss.Height(bottom)); h != m.vp.Height {
++ 		atBottom := m.vp.AtBottom()
++ 		m.vp.Height = h
++ 		if atBottom {
++ 			m.vp.GotoBottom()
++ 		}
++ 	}
++ 	return m.vp.View() + "\n" + bottom
++ }
++ func (m *model) bottom() string {
++ 	var b strings.Builder
++ 	b.WriteString(m.activity() + "\n")
++ 	if m.phase == phaseApproving && len(m.pending) > 0 {
++ 		b.WriteString(m.approvalView() + "\n")
++ 	} else {
++ 		b.WriteString(m.inputBox() + "\n")
++ 	}
++ 	b.WriteString(m.status() + "\n")
++ 	b.WriteString(m.modeLine())
++ 	return b.String()
++ }
++ // activity is the line above the prompt: what the agent is doing on the left,
++ // the effort setting on the right.
++ func (m *model) activity() string {
++ 	var left string
++ 	switch m.phase {
++ 	case phaseRunning:
++ 		verb := verbs[(m.verbSeed+int(time.Since(m.started).Seconds())/4)%len(verbs)]
++ 		if m.interrupting {
++ 			verb = "Interrupting"
++ 		}
++ 		detail := fmt.Sprintf("%ds", int(time.Since(m.started).Seconds()))
++ 		if m.turn > 0 {
++ 			detail += fmt.Sprintf(" · turn %d", m.turn)
++ 		}
++ 		if m.usage.OutputTokens > 0 {
++ 			detail += " · ↓ " + human(m.usage.OutputTokens) + " tokens"
++ 		}
++ 		left = m.spin.View() + " " + styCoral.Render(verb+"…") + styDim.Render(" ("+detail+" · esc to interrupt)")
++ 	case phaseApproving:
++ 		left = styWarn.Render("● waiting for you")
++ 	}
++ 	right := ""
++ 	if m.opts.Effort != "" {
++ 		right = styDim.Render("● "+m.opts.Effort) + styFaint.Render(" · /effort")
++ 	}
++ 	return spread(left, right, m.width)
++ }
++ func (m *model) innerWidth() int { return maxInt(8, m.boxWidth()-4) }
++ // boxWidth keeps the prompt frame usable on a narrow terminal rather than
++ // letting it collapse into a border with no room inside it.
++ func (m *model) boxWidth() int { return maxInt(14, m.width) }
++ func (m *model) inputBox() string {
++ 	style := styBoxFocus
++ 	if m.phase == phaseRunning {
++ 		style = styBoxBlur
++ 	}
++ 	return style.Width(m.boxWidth() - 2).Render(m.input.View())
++ }
++ // status is the pill line under the prompt: who, which model, how full the
++ // context is, and what it has cost so far. The fields are separated by space
++ // rather than by a dot, because the pills already carry their own padding and
++ // a dot between them reads as a gap twice as wide as it is.
++ func (m *model) status() string {
++ 	parts := []string{
++ 		styName.Render(username()),
++ 		styCoral.Render("✳ ") + styDim.Render(prettyModel(m.opts.Client.Model)),
++ 	}
++ 	if pill, ok := m.contextPill(); ok {
++ 		parts = append(parts, pill)
++ 	}
++ 	// Cache reads are reported separately from fresh input: the gap between
++ 	// the two is the whole point of the caching this harness measures.
++ 	u := m.usage
++ 	if u.InputTokens+u.OutputTokens+u.CacheReadInputTokens > 0 {
++ 		io := fmt.Sprintf("↑ %s", human(u.InputTokens))
++ 		if u.CacheReadInputTokens > 0 {
++ 			io += fmt.Sprintf(" ⟳ %s", human(u.CacheReadInputTokens))
++ 		}
++ 		io += fmt.Sprintf(" ↓ %s", human(u.OutputTokens))
++ 		parts = append(parts, styDim.Render(io))
++ 		if cost, known := u.Cost(m.opts.Client.Model); known {
++ 			parts = append(parts, styDim.Render(fmt.Sprintf("$%.4f", cost)))
++ 		}
++ 	}
++ 	return truncateStyled(strings.Join(parts, "  "), maxInt(1, m.width))
++ }
++ // contextPill is the context gauge: how much the model read last turn against
++ // the window it has, coloured by how close that is to full.
++ //
++ // It is one style over the whole pill rather than a coloured glyph inside a
++ // background, because a nested style ends with a reset — which drops the
++ // background for the rest of the pill and leaves a visible tear in it.
++ func (m *model) contextPill() (string, bool) {
++ 	if m.ctxTokens <= 0 {
++ 		return "", false
++ 	}
++ 	pct := m.ctxTokens * 100 / m.contextWindow()
++ 	gauge := colOK
++ 	switch {
++ 	case pct >= 80:
++ 		gauge = colErr
++ 	case pct >= 60:
++ 		gauge = colWarn
++ 	}
++ 	return styPill.Foreground(gauge).Render(fmt.Sprintf("◐ %s (%d%%)", human(m.ctxTokens), pct)), true
++ }
++ func (m *model) contextWindow() int {
++ 	if m.opts.ContextWindow > 0 {
++ 		return m.opts.ContextWindow
++ 	}
++ 	return agent.DefaultContextWindow
++ }
++ // modeLine reports what the approval policy will do next, because a mode that
++ // silently lets the agent write to disk has to be visible at all times.
++ func (m *model) modeLine() string {
++ 	if m.phase == phaseApproving {
++ 		return ""
++ 	}
++ 	if m.opts.Policy != nil && m.opts.Policy.YOLO {
++ 		return truncateStyled(" "+styWarn.Render("⏵⏵ accept-all on")+styFaint.Render(" (shift+tab to cycle)"), maxInt(1, m.width))
++ 	}
++ 	return truncateStyled(" "+styFaint.Render("⏵ approvals on (shift+tab to cycle) · /help for commands"), maxInt(1, m.width))
++ }
++ func (m *model) approvalView() string {
++ 	req := m.pending[0].req
++ 	width := maxInt(20, m.width-2)
++ 	inner := width - 4
++ 	var b strings.Builder
++ 	b.WriteString(styHeading.Render(req.Tool) + styDim.Render(" wants to "+req.Summary) + "\n")
++ 	if req.Detail != "" {
++ 		b.WriteString("\n")
++ 		lines := strings.Split(strings.TrimRight(req.Detail, "\n"), "\n")
++ 		for _, line := range clip(lines, 10) {
++ 			b.WriteString(styText.Render(truncate(line, maxInt(10, inner))) + "\n")
++ 		}
++ 		if n := len(lines) - 10; n > 0 {
++ 			b.WriteString(styFaint.Render("… +"+plural(n, "more line")) + "\n")
++ 		}
++ 	}
++ 	b.WriteString("\n" + styDim.Render("Do you want to proceed?") + "\n")
++ 	for i, c := range m.choices(req) {
++ 		b.WriteString(styKey.Render(fmt.Sprint(i+1)+".") + " " + styText.Render(c.label))
++ 		if alias := c.keys[0]; alias != "enter" {
++ 			b.WriteString(styFaint.Render("  (" + alias + ")"))
++ 		}
++ 		b.WriteString("\n")
++ 	}
++ 	return styModal.Width(width - 2).Render(strings.TrimRight(b.String(), "\n"))
++ }
++ // spread puts left at the left margin and right at the right, and gives up on
++ // the right-hand side rather than overflowing when they cannot both fit.
++ func spread(left, right string, width int) string {
++ 	width = maxInt(1, width)
++ 	lw, rw := lipgloss.Width(left), lipgloss.Width(right)
++ 	if gap := width - lw - rw - 1; gap >= 1 {
++ 		return " " + left + strings.Repeat(" ", gap) + right
++ 	}
++ 	return truncateStyled(" "+left, width)
++ }
++ func username() string {
++ 	for _, k := range []string{"USER", "LOGNAME", "USERNAME"} {
++ 		if v := os.Getenv(k); v != "" {
++ 			return v
++ 		}
++ 	}
++ 	return "you"
++ }
++ func addUsage(a, b llm.Usage) llm.Usage {
++ 	a.InputTokens += b.InputTokens
++ 	a.OutputTokens += b.OutputTokens
++ 	a.CacheReadInputTokens += b.CacheReadInputTokens
++ 	a.CacheCreationInputTokens += b.CacheCreationInputTokens
++ 	return a
++ }

+419−0internal/tui/model_test.goaddedView File

++ package tui
++ import (
++ 	"context"
++ 	"strings"
++ 	"testing"
++ 	tea "github.com/charmbracelet/bubbletea"
++ 	"harness/internal/approval"
++ 	"harness/internal/llm"
++ 	"harness/internal/skills"
++ )
++ // newTestModel builds a model far enough to drive Update/View without a
++ // terminal or a live agent.
++ func newTestModel(t *testing.T) *model {
++ 	t.Helper()
++ 	m := newModel(context.Background(), Options{
++ 		Client: llm.New(llm.WithAPIKey("x")),
++ 		Root:   "/tmp/repo",
++ 		Policy: approval.New(nil),
++ 	})
++ 	m.Update(tea.WindowSizeMsg{Width: 80, Height: 24})
++ 	return m
++ }
++ func key(s string) tea.KeyMsg {
++ 	switch s {
++ 	case "enter":
++ 		return tea.KeyMsg{Type: tea.KeyEnter}
++ 	case "esc":
++ 		return tea.KeyMsg{Type: tea.KeyEsc}
++ 	case "ctrl+c":
++ 		return tea.KeyMsg{Type: tea.KeyCtrlC}
++ 	case "ctrl+r":
++ 		return tea.KeyMsg{Type: tea.KeyCtrlR}
++ 	case "shift+tab":
++ 		return tea.KeyMsg{Type: tea.KeyShiftTab}
++ 	}
++ 	return tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune(s)}
++ }
++ // pend queues an approval the way the bridge would, and returns the channel
++ // the model is expected to answer on.
++ func pend(m *model, req approval.Request) chan approval.Decision {
++ 	reply := make(chan approval.Decision, 1)
++ 	m.Update(approvalMsg{req: req, reply: reply})
++ 	return reply
++ }
++ func TestApprovalKeysMapToDecisions(t *testing.T) {
++ 	cases := []struct {
++ 		key  string
++ 		want approval.Decision
++ 	}{
++ 		{"y", approval.Once},
++ 		{"enter", approval.Once},
++ 		{"n", approval.Deny},
++ 		{"esc", approval.Deny},
++ 		{"t", approval.AlwaysThisTool},
++ 		{"a", approval.AlwaysThisCommand},
++ 	}
++ 	for _, tc := range cases {
++ 		t.Run(tc.key, func(t *testing.T) {
++ 			m := newTestModel(t)
++ 			reply := pend(m, approval.Request{Tool: "bash", Rememberable: true})
++ 			if m.phase != phaseApproving {
++ 				t.Fatalf("phase = %v, want phaseApproving", m.phase)
++ 			}
++ 			m.Update(key(tc.key))
++ 			select {
++ 			case got := <-reply:
++ 				if got != tc.want {
++ 					t.Errorf("decision = %v, want %v", got, tc.want)
++ 				}
++ 			default:
++ 				t.Fatal("no decision was sent")
++ 			}
++ 			if m.phase != phaseRunning {
++ 				t.Errorf("phase = %v after deciding, want phaseRunning", m.phase)
++ 			}
++ 		})
++ 	}
++ }
++ // "always this exact one" is refused for an opaque command, and crucially the
++ // agent stays blocked rather than being silently approved or denied.
++ func TestAlwaysThisCommandRefusedWhenNotRememberable(t *testing.T) {
++ 	m := newTestModel(t)
++ 	reply := pend(m, approval.Request{Tool: "bash", Rememberable: false})
++ 	m.Update(key("a"))
++ 	select {
++ 	case got := <-reply:
++ 		t.Fatalf("sent %v for an unrememberable command; want the prompt to stay open", got)
++ 	default:
++ 	}
++ 	if m.phase != phaseApproving {
++ 		t.Errorf("phase = %v, want the prompt still open", m.phase)
++ 	}
++ 	if !strings.Contains(m.tr.render(), "cannot be remembered") {
++ 		t.Error("no explanation shown for the refusal")
++ 	}
++ 	// It must still be answerable.
++ 	m.Update(key("y"))
++ 	if got := <-reply; got != approval.Once {
++ 		t.Errorf("decision = %v, want Once", got)
++ 	}
++ }
++ func TestUnknownKeyDuringApprovalDoesNothing(t *testing.T) {
++ 	m := newTestModel(t)
++ 	reply := pend(m, approval.Request{Tool: "bash", Rememberable: true})
++ 	m.Update(key("z"))
++ 	select {
++ 	case got := <-reply:
++ 		t.Fatalf("stray key sent decision %v", got)
++ 	default:
++ 	}
++ 	if m.phase != phaseApproving {
++ 		t.Error("stray key dismissed the prompt")
++ 	}
++ }
++ // Queued approvals are answered one at a time, in order.
++ func TestApprovalsAreQueued(t *testing.T) {
++ 	m := newTestModel(t)
++ 	first := pend(m, approval.Request{Tool: "bash", Rememberable: true})
++ 	second := pend(m, approval.Request{Tool: "edit_file", Rememberable: true})
++ 	m.Update(key("y"))
++ 	if got := <-first; got != approval.Once {
++ 		t.Errorf("first decision = %v", got)
++ 	}
++ 	if m.phase != phaseApproving {
++ 		t.Fatal("phase left approving while a second request was queued")
++ 	}
++ 	m.Update(key("n"))
++ 	if got := <-second; got != approval.Deny {
++ 		t.Errorf("second decision = %v", got)
++ 	}
++ 	if m.phase != phaseRunning {
++ 		t.Errorf("phase = %v after the queue drained", m.phase)
++ 	}
++ }
++ // A turn that ends while an approval is outstanding must release the agent
++ // rather than leave it blocked forever.
++ func TestTurnDoneDeniesOutstandingApprovals(t *testing.T) {
++ 	m := newTestModel(t)
++ 	reply := pend(m, approval.Request{Tool: "bash"})
++ 	m.opts.SessionDir = t.TempDir()
++ 	m.Update(turnDone{})
++ 	select {
++ 	case got := <-reply:
++ 		if got != approval.Deny {
++ 			t.Errorf("decision = %v, want Deny", got)
++ 		}
++ 	default:
++ 		t.Fatal("an outstanding approval was never answered")
++ 	}
++ 	if m.phase != phaseIdle {
++ 		t.Errorf("phase = %v, want phaseIdle", m.phase)
++ 	}
++ 	if len(m.pending) != 0 {
++ 		t.Error("pending approvals were not cleared")
++ 	}
++ }
++ func TestCtrlCDuringApprovalDeniesAndInterrupts(t *testing.T) {
++ 	m := newTestModel(t)
++ 	cancelled := false
++ 	m.cancel = func() { cancelled = true }
++ 	reply := pend(m, approval.Request{Tool: "bash"})
++ 	m.Update(key("ctrl+c"))
++ 	if got := <-reply; got != approval.Deny {
++ 		t.Errorf("decision = %v, want Deny", got)
++ 	}
++ 	if !cancelled {
++ 		t.Error("ctrl+c during an approval did not cancel the turn")
++ 	}
++ 	if !m.interrupting {
++ 		t.Error("interrupting flag not set")
++ 	}
++ }
++ func TestCtrlCInterruptsRunningTurnThenQuitsWhenIdle(t *testing.T) {
++ 	m := newTestModel(t)
++ 	cancelled := false
++ 	m.phase = phaseRunning
++ 	m.cancel = func() { cancelled = true }
++ 	if _, cmd := m.Update(key("ctrl+c")); cmd != nil && isQuit(cmd) {
++ 		t.Fatal("ctrl+c quit the program while a turn was running")
++ 	}
++ 	if !cancelled {
++ 		t.Error("running turn was not cancelled")
++ 	}
++ 	if m.quitting {
++ 		t.Error("model marked quitting during a running turn")
++ 	}
++ 	m.phase = phaseIdle
++ 	if _, cmd := m.Update(key("ctrl+c")); cmd == nil || !isQuit(cmd) {
++ 		t.Error("ctrl+c while idle did not quit")
++ 	}
++ }
++ func isQuit(cmd tea.Cmd) bool {
++ 	if cmd == nil {
++ 		return false
++ 	}
++ 	_, ok := cmd().(tea.QuitMsg)
++ 	return ok
++ }
++ func TestSlashCommands(t *testing.T) {
++ 	m := newTestModel(t)
++ 	m.submit("/help")
++ 	if !strings.Contains(m.tr.render(), "/allowed") {
++ 		t.Error("/help did not list commands")
++ 	}
++ 	m.submit("/allowed")
++ 	if !strings.Contains(m.tr.render(), "nothing is permanently allowed") {
++ 		t.Error("/allowed did not report an empty policy")
++ 	}
++ 	m.submit("/nope")
++ 	if !strings.Contains(m.tr.render(), "unknown command") {
++ 		t.Error("an unknown command was not reported")
++ 	}
++ 	m.submit("/clear")
++ 	if len(m.tr.entries) != 0 {
++ 		t.Errorf("/clear left %d entries", len(m.tr.entries))
++ 	}
++ 	if _, cmd := m.submit("/exit"); !isQuit(cmd) {
++ 		t.Error("/exit did not quit")
++ 	}
++ }
++ // Input is refused while the agent is working: accepting it would imply it had
++ // been queued, and nothing would ever send it.
++ func TestSlashSkillsListsThem(t *testing.T) {
++ 	m := newTestModel(t)
++ 	m.opts.Skills = []skills.Skill{
++ 		{Name: "commit-helper", Description: "Use when writing commit messages", Source: "personal"},
++ 	}
++ 	m.submit("/skills")
++ 	out := m.tr.render()
++ 	if !strings.Contains(out, "commit-helper") || !strings.Contains(out, "Use when writing commit messages") {
++ 		t.Errorf("/skills did not list the skill:\n%s", out)
++ 	}
++ }
++ func TestSlashSkillsWithNoneSaysSo(t *testing.T) {
++ 	m := newTestModel(t)
++ 	m.submit("/skills")
++ 	if !strings.Contains(m.tr.render(), "no skills") {
++ 		t.Errorf("/skills with none found said nothing useful:\n%s", m.tr.render())
++ 	}
++ }
++ func TestKnownSkillIsSentAsAUserTurn(t *testing.T) {
++ 	m := newTestModel(t)
++ 	m.opts.Skills = []skills.Skill{{Name: "commit-helper", Description: "d"}}
++ 	m.submit("/commit-helper fix the flaky test")
++ 	if m.phase != phaseRunning {
++ 		t.Errorf("phase = %v, want phaseRunning — the line was not sent", m.phase)
++ 	}
++ 	if !strings.Contains(m.tr.render(), "/commit-helper fix the flaky test") {
++ 		t.Errorf("the user turn is not in the transcript:\n%s", m.tr.render())
++ 	}
++ }
++ func TestUnknownSlashCommandStillErrors(t *testing.T) {
++ 	m := newTestModel(t)
++ 	m.opts.Skills = []skills.Skill{{Name: "commit-helper", Description: "d"}}
++ 	m.submit("/commit-helpr")
++ 	if m.phase == phaseRunning {
++ 		t.Error("a typo was sent to the model instead of being caught")
++ 	}
++ 	if !strings.Contains(m.tr.render(), "unknown command") {
++ 		t.Errorf("no error for the typo:\n%s", m.tr.render())
++ 	}
++ }
++ func TestHelpMentionsSkills(t *testing.T) {
++ 	m := newTestModel(t)
++ 	m.submit("/help")
++ 	if !strings.Contains(m.tr.render(), "/skills") {
++ 		t.Error("/help does not mention /skills")
++ 	}
++ }
++ func TestEnterIgnoredWhileRunning(t *testing.T) {
++ 	m := newTestModel(t)
++ 	m.phase = phaseRunning
++ 	m.input.SetValue("another thing")
++ 	m.Update(key("enter"))
++ 	if m.input.Value() != "another thing" {
++ 		t.Error("input was consumed while a turn was running")
++ 	}
++ }
++ func TestUsageAccumulatesAcrossTurns(t *testing.T) {
++ 	m := newTestModel(t)
++ 	m.Update(evUsage{usage: llm.Usage{InputTokens: 10, OutputTokens: 3, CacheReadInputTokens: 100}})
++ 	m.Update(evUsage{usage: llm.Usage{InputTokens: 5, OutputTokens: 2}})
++ 	if m.usage.InputTokens != 15 || m.usage.OutputTokens != 5 || m.usage.CacheReadInputTokens != 100 {
++ 		t.Errorf("usage = %+v, want in 15 out 5 cached 100", m.usage)
++ 	}
++ 	if s := m.status(); !strings.Contains(s, "15") {
++ 		t.Errorf("status line does not show usage: %q", s)
++ 	}
++ }
++ // The cost is the last field on the status line and the easiest one to lose to
++ // a width miscount; at a normal width it must survive intact.
++ func TestStatusLineKeepsCostAtNormalWidth(t *testing.T) {
++ 	m := newTestModel(t)
++ 	m.Update(tea.WindowSizeMsg{Width: 120, Height: 30})
++ 	m.Update(evUsage{usage: llm.Usage{InputTokens: 2400, OutputTokens: 190, CacheReadInputTokens: 16000}})
++ 	status := m.status()
++ 	if _, known := m.usage.Cost(m.opts.Client.Model); !known {
++ 		t.Skip("no pricing for the test model")
++ 	}
++ 	if strings.HasSuffix(strings.TrimSpace(status), "…") {
++ 		t.Errorf("status line was truncated at width 120: %q", status)
++ 	}
++ 	if !strings.Contains(status, "$") {
++ 		t.Errorf("cost missing from the status line: %q", status)
++ 	}
++ }
++ // Approving a call records the decision on that call, so the transcript reads
++ // in the order things actually happened.
++ func TestApprovalNoteAttachesToTheCall(t *testing.T) {
++ 	m := newTestModel(t)
++ 	m.tr.startTool("bash", "command=go build ./...")
++ 	reply := pend(m, approval.Request{Tool: "bash", Rememberable: true})
++ 	m.Update(key("y"))
++ 	<-reply
++ 	m.tr.finishTool("bash", "build ok", false)
++ 	out := m.tr.render()
++ 	note, result := strings.Index(out, "approved once"), strings.Index(out, "build ok")
++ 	if note < 0 || result < 0 || note > result {
++ 		t.Errorf("approval did not render with the call it gated:\n%s", out)
++ 	}
++ }
++ func TestToggleVerboseRedrawsTranscript(t *testing.T) {
++ 	m := newTestModel(t)
++ 	m.tr.startTool("bash", "command=go test")
++ 	m.tr.finishTool("bash", strings.Repeat("noise\n", 30), false)
++ 	if !strings.Contains(m.tr.render(), "more lines") {
++ 		t.Fatal("output was not collapsed to begin with")
++ 	}
++ 	m.Update(key("ctrl+r"))
++ 	if strings.Contains(m.tr.render(), "more lines") {
++ 		t.Error("ctrl+r did not expand tool output")
++ 	}
++ }
++ // The view must render at any size without panicking; a resize to something
++ // tiny is the classic crash.
++ func TestViewRendersAtAwkwardSizes(t *testing.T) {
++ 	for _, size := range [][2]int{{80, 24}, {20, 6}, {200, 60}, {1, 1}} {
++ 		m := newTestModel(t)
++ 		m.Update(tea.WindowSizeMsg{Width: size[0], Height: size[1]})
++ 		m.tr.addUser("hello")
++ 		m.tr.startTool("edit_file", "path=main.go")
++ 		m.tr.finishTool("edit_file", "--- a\n+++ b\n@@ -1 +1 @@\n-x\n+y\n", false)
++ 		m.sync()
++ 		if got := m.View(); got == "" {
++ 			t.Errorf("empty view at %dx%d", size[0], size[1])
++ 		}
++ 		pend(m, approval.Request{Tool: "bash", Summary: "run a shell command", Detail: "rm -rf /", Rememberable: false})
++ 		if got := m.View(); !strings.Contains(got, "bash") {
++ 			t.Errorf("approval not shown at %dx%d", size[0], size[1])
++ 		}
++ 	}
++ }
++ func TestViewShowsApprovalOptionsConditionally(t *testing.T) {
++ 	m := newTestModel(t)
++ 	pend(m, approval.Request{Tool: "bash", Summary: "run it", Detail: "ls", Rememberable: true})
++ 	if got := m.approvalView(); !strings.Contains(got, "always this exact one") {
++ 		t.Error("rememberable request did not offer the exact-command option")
++ 	}
++ 	m2 := newTestModel(t)
++ 	pend(m2, approval.Request{Tool: "bash", Summary: "run it", Detail: "eval $(x)", Rememberable: false})
++ 	if got := m2.approvalView(); strings.Contains(got, "always this exact one") {
++ 		t.Error("opaque command offered an option that would be a lie")
++ 	}
++ }

+64−0internal/tui/splash.goaddedView File

++ package tui
++ import (
++ 	"strings"
++ 	"github.com/charmbracelet/lipgloss"
++ )
++ // mascot is drawn with half-blocks from the box-drawing range, so it needs no
++ // patched font and degrades to something recognisable in a plain xterm.
++ var mascot = []string{
++ 	" ▄▄▄▄▄▄ ",
++ 	"▐▀█▀█▀█▌",
++ 	"▐██████▌",
++ 	" ▀▀  ▀▀ ",
++ }
++ const mascotGap = "   "
++ // splash is the welcome block. It goes into the scrollback rather than into
++ // fixed chrome, so it scrolls away once there is real work to look at instead
++ // of permanently taxing four rows of a small terminal.
++ //
++ // On a narrow terminal the mascot is dropped rather than sliced: half a mascot
++ // reads as a rendering bug, where the three text lines alone read as a choice.
++ func splash(o Options, width int) string {
++ 	name := styHeading.Render("harness")
++ 	if o.Version != "" {
++ 		name += " " + styDim.Render(o.Version)
++ 	}
++ 	lines := []string{
++ 		name,
++ 		styDim.Render(prettyModel(o.Client.Model) + " · " + endpointLabel(o.Client)),
++ 		styDim.Render(shortenHome(o.Root)),
++ 	}
++ 	// The mascot is dropped only when the terminal cannot hold it beside a
++ 	// readable amount of text. It is measured against a minimum rather than
++ 	// against the longest line, or a deeply nested working directory would
++ 	// silently cost you the whole welcome block.
++ 	art := mascot
++ 	if width < artWidth()+minSplashText {
++ 		art = nil
++ 	}
++ 	var b strings.Builder
++ 	for i := 0; i < maxInt(len(art), len(lines)); i++ {
++ 		var line string
++ 		if i < len(art) {
++ 			line = styCoral.Render(art[i]) + mascotGap
++ 		}
++ 		if i < len(lines) {
++ 			line += lines[i]
++ 		}
++ 		b.WriteString(truncateStyled(line, maxInt(1, width)) + "\n")
++ 	}
++ 	return b.String()
++ }
++ // minSplashText is how much room the text beside the mascot needs before the
++ // mascot stops being worth its columns.
++ const minSplashText = 24
++ func artWidth() int { return lipgloss.Width(mascot[1]) + lipgloss.Width(mascotGap) }

+77−0internal/tui/styles.goaddedView File

++ // Package tui is a full-screen terminal front end built on Bubble Tea.
++ //
++ // It observes the same agent.Event stream the plain renderer does and answers
++ // the same approval.Prompt signature, so the dependency direction is unchanged:
++ // tui imports agent, never the reverse, and the eval runner still drives the
++ // loop with no terminal attached.
++ package tui
++ import "github.com/charmbracelet/lipgloss"
++ // The palette is warm rather than neutral: one coral accent carries the
++ // identity and everything else is a grey at some distance from the text
++ // colour. Every colour is adaptive, because a palette tuned only for a dark
++ // terminal is the usual way a hand-rolled TUI becomes unreadable on a light
++ // one.
++ var (
++ 	colCoral  = lipgloss.AdaptiveColor{Light: "#b4532f", Dark: "#d97757"}
++ 	colText   = lipgloss.AdaptiveColor{Light: "#1c1b1a", Dark: "#e8e6e3"}
++ 	colUser   = lipgloss.AdaptiveColor{Light: "#4b4945", Dark: "#b3ada4"}
++ 	colDim    = lipgloss.AdaptiveColor{Light: "#6f6a66", Dark: "#8a847d"}
++ 	colFaint  = lipgloss.AdaptiveColor{Light: "#c9c4be", Dark: "#3f3b38"}
++ 	colOK     = lipgloss.AdaptiveColor{Light: "#2f7d46", Dark: "#5dbb7a"}
++ 	colErr    = lipgloss.AdaptiveColor{Light: "#b3261e", Dark: "#eb6f6f"}
++ 	colWarn   = lipgloss.AdaptiveColor{Light: "#8a5a00", Dark: "#e0a458"}
++ 	colBlue   = lipgloss.AdaptiveColor{Light: "#2f5fa8", Dark: "#7aa2e3"}
++ 	colPillBg = lipgloss.AdaptiveColor{Light: "#ebe7e2", Dark: "#2b2825"}
++ )
++ var (
++ 	styText  = lipgloss.NewStyle().Foreground(colText)
++ 	styDim   = lipgloss.NewStyle().Foreground(colDim)
++ 	styFaint = lipgloss.NewStyle().Foreground(colFaint)
++ 	styCoral = lipgloss.NewStyle().Foreground(colCoral)
++ 	styBold  = lipgloss.NewStyle().Bold(true)
++ 	styErr   = lipgloss.NewStyle().Foreground(colErr)
++ 	styWarn  = lipgloss.NewStyle().Foreground(colWarn)
++ 	styOK    = lipgloss.NewStyle().Foreground(colOK)
++ 	// The transcript's grammar: every turn of events opens with a dot, and
++ 	// anything hanging off it is indented under that dot.
++ 	styUserMark = lipgloss.NewStyle().Foreground(colDim)
++ 	styUserText = lipgloss.NewStyle().Foreground(colUser)
++ 	styToolDot  = lipgloss.NewStyle().Foreground(colCoral)
++ 	styTextDot  = lipgloss.NewStyle().Foreground(colText)
++ 	styErrDot   = lipgloss.NewStyle().Foreground(colErr)
++ 	styToolName = lipgloss.NewStyle().Foreground(colText).Bold(true)
++ 	styToolArgs = lipgloss.NewStyle().Foreground(colDim)
++ 	styResult   = lipgloss.NewStyle().Foreground(colDim)
++ 	styDiffAdd  = lipgloss.NewStyle().Foreground(colOK)
++ 	styDiffDel  = lipgloss.NewStyle().Foreground(colErr)
++ 	styDiffHunk = lipgloss.NewStyle().Foreground(colCoral)
++ 	styDiffHead = lipgloss.NewStyle().Foreground(colDim).Bold(true)
++ 	styName    = lipgloss.NewStyle().Foreground(colBlue).Background(colPillBg).Padding(0, 1)
++ 	styPill    = lipgloss.NewStyle().Foreground(colDim).Background(colPillBg).Padding(0, 1)
++ 	styKey     = lipgloss.NewStyle().Foreground(colCoral).Bold(true)
++ 	styHeading = lipgloss.NewStyle().Foreground(colCoral).Bold(true)
++ 	// The input frame is the only always-present chrome, so it carries the
++ 	// mode: coral when it is yours to type into, faint while the agent has it.
++ 	styBoxFocus = lipgloss.NewStyle().
++ 			Border(lipgloss.RoundedBorder()).
++ 			BorderForeground(colCoral).
++ 			Padding(0, 1)
++ 	styBoxBlur = lipgloss.NewStyle().
++ 			Border(lipgloss.RoundedBorder()).
++ 			BorderForeground(colFaint).
++ 			Padding(0, 1)
++ 	// The approval box is the one place the UI is allowed to shout: it is the
++ 	// only moment a human has to decide something.
++ 	styModal = lipgloss.NewStyle().
++ 			Border(lipgloss.RoundedBorder()).
++ 			BorderForeground(colCoral).
++ 			Padding(0, 1)
++ )

+104−0internal/tui/testdata/mockapi/main.goaddedView File

++ // Command mockapi is a fake Messages API for exercising the TUI by hand,
++ // without an API key and without spending anything.
++ //
++ // It lives under testdata so it is invisible to ./... — it is a manual test
++ // fixture, not part of the build.
++ //
++ //	go run ./internal/tui/testdata/mockapi &
++ //	./harness -C /tmp/demo -base-url http://127.0.0.1:8899 -api-key mock
++ //
++ // The script is fixed: the first turn streams a sentence and asks to run a
++ // shell command, which makes the TUI raise an approval prompt; once a
++ // tool_result comes back it streams a closing sentence and stops. That covers
++ // streaming, tool rendering, approve, deny, and interrupt.
++ //
++ // Flags: -addr to move it, -fail to make the command exit non-zero, -slow to
++ // stretch the stream out for watching the spinner and ctrl-c.
++ package main
++ import (
++ 	"encoding/json"
++ 	"flag"
++ 	"fmt"
++ 	"io"
++ 	"log"
++ 	"net/http"
++ 	"strings"
++ 	"time"
++ )
++ var (
++ 	addr = flag.String("addr", "127.0.0.1:8899", "listen address")
++ 	slow = flag.Duration("slow", 0, "pause between streamed words, e.g. 150ms")
++ 	cmd  = flag.String("cmd", "git status --short && go build ./...", "command the model asks to run")
++ )
++ func main() {
++ 	flag.Parse()
++ 	http.HandleFunc("/v1/messages", handle)
++ 	log.Printf("mock Messages API on http://%s", *addr)
++ 	log.Fatal(http.ListenAndServe(*addr, nil))
++ }
++ func handle(w http.ResponseWriter, r *http.Request) {
++ 	body, _ := io.ReadAll(r.Body)
++ 	// A tool_result in the history means the harness ran (or refused) our
++ 	// command and fed the outcome back, so the next turn is the last one.
++ 	final := strings.Contains(string(body), "tool_result")
++ 	w.Header().Set("Content-Type", "text/event-stream")
++ 	w.WriteHeader(http.StatusOK)
++ 	send(w, "message_start", map[string]any{
++ 		"type": "message_start",
++ 		"message": map[string]any{
++ 			"id": "msg_mock", "model": "claude-opus-5",
++ 			"usage": map[string]any{"input_tokens": 1200, "cache_read_input_tokens": 8000},
++ 		},
++ 	})
++ 	text := "Checking the repository state first."
++ 	if final {
++ 		text = "That is everything I can tell from here."
++ 	}
++ 	send(w, "content_block_start", map[string]any{
++ 		"type": "content_block_start", "index": 0,
++ 		"content_block": map[string]any{"type": "text", "text": ""},
++ 	})
++ 	for _, word := range strings.SplitAfter(text, " ") {
++ 		send(w, "content_block_delta", map[string]any{
++ 			"type": "content_block_delta", "index": 0,
++ 			"delta": map[string]any{"type": "text_delta", "text": word},
++ 		})
++ 		time.Sleep(*slow)
++ 	}
++ 	send(w, "content_block_stop", map[string]any{"type": "content_block_stop", "index": 0})
++ 	stop := "end_turn"
++ 	if !final {
++ 		stop = "tool_use"
++ 		send(w, "content_block_start", map[string]any{
++ 			"type": "content_block_start", "index": 1,
++ 			"content_block": map[string]any{"type": "tool_use", "id": "toolu_1", "name": "bash"},
++ 		})
++ 		args, _ := json.Marshal(map[string]string{"command": *cmd})
++ 		send(w, "content_block_delta", map[string]any{
++ 			"type": "content_block_delta", "index": 1,
++ 			"delta": map[string]any{"type": "input_json_delta", "partial_json": string(args)},
++ 		})
++ 		send(w, "content_block_stop", map[string]any{"type": "content_block_stop", "index": 1})
++ 	}
++ 	send(w, "message_delta", map[string]any{
++ 		"type":  "message_delta",
++ 		"delta": map[string]any{"stop_reason": stop},
++ 		"usage": map[string]any{"output_tokens": 95},
++ 	})
++ 	send(w, "message_stop", map[string]any{"type": "message_stop"})
++ }
++ func send(w http.ResponseWriter, event string, data any) {
++ 	b, _ := json.Marshal(data)
++ 	fmt.Fprintf(w, "event: %s\ndata: %s\n\n", event, b)
++ 	w.(http.Flusher).Flush()
++ }

+380−0internal/tui/transcript.goaddedView File

++ package tui
++ import (
++ 	"encoding/json"
++ 	"fmt"
++ 	"sort"
++ 	"strings"
++ 	"github.com/charmbracelet/lipgloss"
++ 	"github.com/charmbracelet/x/ansi"
++ )
++ type entryKind int
++ const (
++ 	entryUser entryKind = iota
++ 	entryAssistant
++ 	entryTool
++ 	entryNotice
++ 	entryError
++ 	// entryRaw is already-styled text the transcript passes through
++ 	// untouched: the welcome block, which owns its own layout.
++ 	entryRaw
++ )
++ // entry is one thing that happened, kept structured rather than pre-rendered
++ // so a resize or a verbosity toggle can redraw the whole history correctly.
++ type entry struct {
++ 	kind    entryKind
++ 	text    string
++ 	tool    string
++ 	input   string
++ 	result  string
++ 	isError bool
++ 	// note is a decision recorded against this call — an approval or a
++ 	// denial — kept on the entry so it renders with the call rather than
++ 	// after the result that came back later.
++ 	note string
++ 	// open means more is still arriving: streamed text, or a tool call whose
++ 	// result has not come back yet.
++ 	open bool
++ }
++ // collapsedLines is how much of a tool result is shown before it is elided.
++ // Diffs get a larger budget because a diff is the record of what changed.
++ const (
++ 	collapsedLines = 6
++ 	collapsedDiff  = 40
++ )
++ // The transcript reads as a column of events hanging off a gutter: a dot
++ // opens each one, and everything belonging to it is indented under the dot.
++ const (
++ 	dot    = "⏺"
++ 	branch = "⎿"
++ 	gutter = "  "
++ )
++ // transcript is the scrollback. It renders to a single string for the
++ // viewport, and caches that string because re-rendering a long session on
++ // every frame is wasteful.
++ type transcript struct {
++ 	entries []entry
++ 	width   int
++ 	verbose bool
++ 	cache string
++ 	dirty bool
++ }
++ func newTranscript(width int) *transcript {
++ 	return &transcript{width: width, dirty: true}
++ }
++ func (t *transcript) setWidth(w int) {
++ 	if w != t.width {
++ 		t.width, t.dirty = w, true
++ 	}
++ }
++ func (t *transcript) setVerbose(v bool) {
++ 	if v != t.verbose {
++ 		t.verbose, t.dirty = v, true
++ 	}
++ }
++ func (t *transcript) clear() {
++ 	t.entries, t.dirty = nil, true
++ }
++ func (t *transcript) add(e entry) {
++ 	t.closeOpen()
++ 	t.entries = append(t.entries, e)
++ 	t.dirty = true
++ }
++ func (t *transcript) addUser(s string)   { t.add(entry{kind: entryUser, text: s}) }
++ func (t *transcript) addNotice(s string) { t.add(entry{kind: entryNotice, text: s}) }
++ func (t *transcript) addError(s string)  { t.add(entry{kind: entryError, text: s}) }
++ func (t *transcript) addRaw(s string)    { t.add(entry{kind: entryRaw, text: s}) }
++ // closeOpen finalises a streaming assistant entry. A tool call arriving
++ // mid-sentence ends the sentence, which is what the plain renderer does with
++ // its newline bookkeeping.
++ func (t *transcript) closeOpen() {
++ 	if n := len(t.entries); n > 0 && t.entries[n-1].kind == entryAssistant && t.entries[n-1].open {
++ 		t.entries[n-1].open = false
++ 		t.entries[n-1].text = strings.TrimRight(t.entries[n-1].text, "\n")
++ 		t.dirty = true
++ 	}
++ }
++ // appendDelta adds streamed text, continuing the current assistant entry
++ // rather than starting a new one per token.
++ func (t *transcript) appendDelta(s string) {
++ 	if n := len(t.entries); n > 0 && t.entries[n-1].kind == entryAssistant && t.entries[n-1].open {
++ 		t.entries[n-1].text += s
++ 		t.dirty = true
++ 		return
++ 	}
++ 	t.entries = append(t.entries, entry{kind: entryAssistant, text: s, open: true})
++ 	t.dirty = true
++ }
++ func (t *transcript) startTool(name, input string) {
++ 	t.closeOpen()
++ 	t.entries = append(t.entries, entry{kind: entryTool, tool: name, input: input, open: true})
++ 	t.dirty = true
++ }
++ // annotateTool records a decision against the most recent unfinished call of
++ // that tool. Approval happens before the tool runs, so appending it as its own
++ // entry would print it after the result it gated.
++ func (t *transcript) annotateTool(name, note string) {
++ 	for i := len(t.entries) - 1; i >= 0; i-- {
++ 		if t.entries[i].kind == entryTool && t.entries[i].open && t.entries[i].tool == name {
++ 			t.entries[i].note = note
++ 			t.dirty = true
++ 			return
++ 		}
++ 	}
++ 	t.addNotice(gutter + branch + " " + note)
++ }
++ // finishTool attaches a result to the most recent unfinished call of that
++ // tool. Matching by name from the end is enough: the loop dispatches calls in
++ // order and reports each result as it lands.
++ func (t *transcript) finishTool(name, result string, isErr bool) {
++ 	for i := len(t.entries) - 1; i >= 0; i-- {
++ 		if t.entries[i].kind == entryTool && t.entries[i].open && t.entries[i].tool == name {
++ 			t.entries[i].result = result
++ 			t.entries[i].isError = isErr
++ 			t.entries[i].open = false
++ 			t.dirty = true
++ 			return
++ 		}
++ 	}
++ 	// No matching call: show it anyway rather than silently dropping evidence.
++ 	t.entries = append(t.entries, entry{kind: entryTool, tool: name, result: result, isError: isErr})
++ 	t.dirty = true
++ }
++ // render produces the full scrollback. Entries are separated by a blank line,
++ // which is most of what makes a wall of tool output readable.
++ func (t *transcript) render() string {
++ 	if !t.dirty {
++ 		return t.cache
++ 	}
++ 	var b strings.Builder
++ 	for i, e := range t.entries {
++ 		if i > 0 {
++ 			b.WriteByte('\n')
++ 		}
++ 		b.WriteString(t.renderEntry(e))
++ 	}
++ 	t.cache, t.dirty = b.String(), false
++ 	return t.cache
++ }
++ func (t *transcript) renderEntry(e entry) string {
++ 	width := t.width
++ 	if width < 20 {
++ 		width = 20
++ 	}
++ 	switch e.kind {
++ 	case entryRaw:
++ 		return e.text
++ 	case entryUser:
++ 		return hang(styUserMark.Render(">"), styUserText.Width(width-2).Render(e.text))
++ 	case entryAssistant:
++ 		return hang(styTextDot.Render(dot), styText.Width(width-2).Render(strings.TrimRight(e.text, "\n")))
++ 	case entryNotice:
++ 		return styDim.Width(width).Render(e.text) + "\n"
++ 	case entryError:
++ 		return hang(styErrDot.Render(dot), styErr.Width(width-2).Render(e.text))
++ 	case entryTool:
++ 		return t.renderTool(e, width)
++ 	}
++ 	return ""
++ }
++ // hang renders a marker and a body so the body's continuation lines line up
++ // under its first line rather than under the marker.
++ func hang(mark, body string) string {
++ 	var b strings.Builder
++ 	for i, line := range strings.Split(strings.TrimRight(body, "\n"), "\n") {
++ 		if i == 0 {
++ 			b.WriteString(mark + " " + line + "\n")
++ 			continue
++ 		}
++ 		b.WriteString(gutter + line + "\n")
++ 	}
++ 	return b.String()
++ }
++ func (t *transcript) renderTool(e entry, width int) string {
++ 	var b strings.Builder
++ 	name := camel(e.tool)
++ 	args := ""
++ 	if e.input != "" {
++ 		args = "(" + truncate(e.input, maxInt(10, width-lipgloss.Width(name)-6)) + ")"
++ 	}
++ 	b.WriteString(styToolDot.Render(dot) + " " + styToolName.Render(name) + styToolArgs.Render(args) + "\n")
++ 	if e.note != "" {
++ 		b.WriteString(styDim.Render(gutter+branch+" "+e.note) + "\n")
++ 	}
++ 	if e.open {
++ 		b.WriteString(styFaint.Render(gutter+branch+" …") + "\n")
++ 		return b.String()
++ 	}
++ 	if strings.TrimSpace(e.result) == "" && !e.isError {
++ 		return b.String()
++ 	}
++ 	// A diff is the one result worth showing in full and in colour.
++ 	if !e.isError && looksLikeDiff(e.result) {
++ 		lines := strings.Split(strings.TrimRight(e.result, "\n"), "\n")
++ 		b.WriteString(styDim.Render(gutter+diffStat(lines)) + "\n")
++ 		limit := collapsedDiff
++ 		if t.verbose {
++ 			limit = len(lines)
++ 		}
++ 		for _, line := range clip(lines, limit) {
++ 			b.WriteString(gutter + colorDiffLine(line, width-len(gutter)) + "\n")
++ 		}
++ 		if n := len(lines) - limit; n > 0 {
++ 			b.WriteString(styFaint.Render(fmt.Sprintf("%s… +%s of diff (ctrl+r)", gutter, plural(n, "more line"))) + "\n")
++ 		}
++ 		return b.String()
++ 	}
++ 	style, prefix := styResult, gutter+branch+" "
++ 	if e.isError {
++ 		style, prefix = styErr, gutter+branch+" error: "
++ 	}
++ 	lines := strings.Split(strings.TrimRight(e.result, "\n"), "\n")
++ 	limit := collapsedLines
++ 	if t.verbose {
++ 		limit = len(lines)
++ 	}
++ 	cont := strings.Repeat(" ", lipgloss.Width(gutter+branch+" "))
++ 	for i, line := range clip(lines, limit) {
++ 		pad := prefix
++ 		if i > 0 {
++ 			pad = cont
++ 		}
++ 		b.WriteString(style.Render(pad+truncate(line, maxInt(10, width-lipgloss.Width(pad)))) + "\n")
++ 	}
++ 	if n := len(lines) - limit; n > 0 {
++ 		b.WriteString(styFaint.Render(fmt.Sprintf("%s… +%s (ctrl+r)", cont, plural(n, "more line"))) + "\n")
++ 	}
++ 	return b.String()
++ }
++ // diffStat counts what a diff did, so the header says how big a change this
++ // was before the reader has to measure it by eye. The +++/--- file headers are
++ // not edits and must not be counted as any.
++ func diffStat(lines []string) string {
++ 	add, del := 0, 0
++ 	for _, line := range lines {
++ 		switch {
++ 		case strings.HasPrefix(line, "+++"), strings.HasPrefix(line, "---"):
++ 		case strings.HasPrefix(line, "+"):
++ 			add++
++ 		case strings.HasPrefix(line, "-"):
++ 			del++
++ 		}
++ 	}
++ 	return fmt.Sprintf("%s, %s", plural(add, "addition"), plural(del, "removal"))
++ }
++ func plural(n int, word string) string {
++ 	if n == 1 {
++ 		return fmt.Sprintf("%d %s", n, word)
++ 	}
++ 	return fmt.Sprintf("%d %ss", n, word)
++ }
++ func colorDiffLine(line string, width int) string {
++ 	line = truncate(line, maxInt(10, width))
++ 	switch {
++ 	case strings.HasPrefix(line, "+++"), strings.HasPrefix(line, "---"):
++ 		return styDiffHead.Render(line)
++ 	case strings.HasPrefix(line, "@@"):
++ 		return styDiffHunk.Render(line)
++ 	case strings.HasPrefix(line, "+"):
++ 		return styDiffAdd.Render(line)
++ 	case strings.HasPrefix(line, "-"):
++ 		return styDiffDel.Render(line)
++ 	}
++ 	return styResult.Render(line)
++ }
++ // looksLikeDiff reports whether s is a unified diff, so a tool result can be
++ // rendered appropriately without the tool having to say which it is.
++ func looksLikeDiff(s string) bool {
++ 	return strings.HasPrefix(s, "--- ") && strings.Contains(s, "\n@@ ")
++ }
++ func clip(lines []string, n int) []string {
++ 	if n < 0 || n >= len(lines) {
++ 		return lines
++ 	}
++ 	return lines[:n]
++ }
++ // truncate cuts to n display cells, counting runes rather than bytes so a
++ // multi-byte path does not get sliced mid-character. It is for unstyled text.
++ func truncate(s string, n int) string {
++ 	if n <= 0 {
++ 		return ""
++ 	}
++ 	r := []rune(s)
++ 	if len(r) <= n {
++ 		return s
++ 	}
++ 	return string(r[:n-1]) + "…"
++ }
++ // truncateStyled cuts a string that already carries ANSI styling. Counting
++ // runes there would measure escape sequences as if they were visible and cut
++ // the line far too early — which is exactly how a status bar loses its last
++ // field to a colour code.
++ func truncateStyled(s string, n int) string {
++ 	if n <= 0 {
++ 		return ""
++ 	}
++ 	if lipgloss.Width(s) <= n {
++ 		return s
++ 	}
++ 	return ansi.Truncate(s, n, "…")
++ }
++ // summarizeInput renders tool arguments as k=v, sorted so the same call always
++ // prints the same way.
++ func summarizeInput(raw json.RawMessage) string {
++ 	var m map[string]any
++ 	if len(raw) == 0 || json.Unmarshal(raw, &m) != nil {
++ 		return string(raw)
++ 	}
++ 	keys := make([]string, 0, len(m))
++ 	for k := range m {
++ 		keys = append(keys, k)
++ 	}
++ 	sort.Strings(keys)
++ 	parts := make([]string, 0, len(keys))
++ 	for _, k := range keys {
++ 		v := strings.ReplaceAll(fmt.Sprintf("%v", m[k]), "\n", "⏎")
++ 		parts = append(parts, fmt.Sprintf("%s=%s", k, truncate(v, 60)))
++ 	}
++ 	return strings.Join(parts, ", ")
++ }

+256−0internal/tui/transcript_test.goaddedView File

++ package tui
++ import (
++ 	"encoding/json"
++ 	"strings"
++ 	"testing"
++ 	"github.com/charmbracelet/lipgloss"
++ )
++ func TestAppendDeltaCoalesces(t *testing.T) {
++ 	tr := newTranscript(80)
++ 	tr.appendDelta("Hel")
++ 	tr.appendDelta("lo ")
++ 	tr.appendDelta("world")
++ 	if len(tr.entries) != 1 {
++ 		t.Fatalf("streamed text made %d entries, want 1", len(tr.entries))
++ 	}
++ 	if got := tr.entries[0].text; got != "Hello world" {
++ 		t.Errorf("text = %q, want %q", got, "Hello world")
++ 	}
++ }
++ // A tool call arriving mid-sentence must close the streaming entry rather than
++ // interleave with it: this is the bug the line renderer's midLine flag exists
++ // to prevent, and the transcript has to handle it structurally.
++ func TestToolCallClosesStreamingText(t *testing.T) {
++ 	tr := newTranscript(80)
++ 	tr.appendDelta("let me look\n")
++ 	tr.startTool("grep", "pattern=foo")
++ 	tr.appendDelta("found it")
++ 	if len(tr.entries) != 3 {
++ 		t.Fatalf("got %d entries, want 3", len(tr.entries))
++ 	}
++ 	if tr.entries[0].open {
++ 		t.Error("first text entry still open after a tool call")
++ 	}
++ 	if tr.entries[0].text != "let me look" {
++ 		t.Errorf("trailing newline not trimmed: %q", tr.entries[0].text)
++ 	}
++ 	if tr.entries[2].kind != entryAssistant {
++ 		t.Error("text after a tool call should start a new assistant entry")
++ 	}
++ }
++ func TestFinishToolMatchesMostRecentOpenCall(t *testing.T) {
++ 	tr := newTranscript(80)
++ 	tr.startTool("read_file", "path=a.go")
++ 	tr.finishTool("read_file", "1: package a", false)
++ 	tr.startTool("read_file", "path=b.go")
++ 	tr.finishTool("read_file", "1: package b", false)
++ 	if got := tr.entries[0].result; got != "1: package a" {
++ 		t.Errorf("first call result overwritten: %q", got)
++ 	}
++ 	if got := tr.entries[1].result; got != "1: package b" {
++ 		t.Errorf("second call result = %q", got)
++ 	}
++ 	for i, e := range tr.entries {
++ 		if e.open {
++ 			t.Errorf("entry %d still open", i)
++ 		}
++ 	}
++ }
++ // A result with no matching call still has to appear. Dropping it would hide
++ // evidence of what the agent actually did.
++ func TestFinishToolWithoutStartStillRecords(t *testing.T) {
++ 	tr := newTranscript(80)
++ 	tr.finishTool("bash", "boom", true)
++ 	if len(tr.entries) != 1 {
++ 		t.Fatalf("got %d entries, want 1", len(tr.entries))
++ 	}
++ 	if !tr.entries[0].isError || tr.entries[0].result != "boom" {
++ 		t.Errorf("orphan result not recorded: %+v", tr.entries[0])
++ 	}
++ }
++ func TestRenderCollapsesLongOutputAndVerboseExpands(t *testing.T) {
++ 	long := strings.Repeat("line\n", 40)
++ 	tr := newTranscript(100)
++ 	tr.startTool("bash", "command=go test ./...")
++ 	tr.finishTool("bash", long, false)
++ 	out := tr.render()
++ 	if !strings.Contains(out, "more lines") {
++ 		t.Error("long output was not collapsed")
++ 	}
++ 	tr.setVerbose(true)
++ 	if got := tr.render(); strings.Contains(got, "more lines") {
++ 		t.Error("verbose mode still collapsed the output")
++ 	}
++ }
++ func TestRenderCachesUntilDirty(t *testing.T) {
++ 	tr := newTranscript(80)
++ 	tr.addUser("hello")
++ 	first := tr.render()
++ 	if tr.dirty {
++ 		t.Fatal("still dirty after render")
++ 	}
++ 	tr.addUser("again")
++ 	if !tr.dirty {
++ 		t.Fatal("adding an entry did not invalidate the cache")
++ 	}
++ 	if second := tr.render(); second == first {
++ 		t.Error("render returned stale content after a new entry")
++ 	}
++ }
++ func TestSetWidthInvalidatesCache(t *testing.T) {
++ 	tr := newTranscript(80)
++ 	tr.addUser("hello")
++ 	tr.render()
++ 	tr.setWidth(80) // unchanged: must not dirty
++ 	if tr.dirty {
++ 		t.Error("setting the same width invalidated the cache")
++ 	}
++ 	tr.setWidth(40)
++ 	if !tr.dirty {
++ 		t.Error("a width change did not invalidate the cache")
++ 	}
++ }
++ func TestDiffIsRenderedAsDiff(t *testing.T) {
++ 	diff := "--- a/x.go\n+++ b/x.go\n@@ -1 +1 @@\n-old\n+new\n"
++ 	if !looksLikeDiff(diff) {
++ 		t.Fatal("looksLikeDiff rejected a unified diff")
++ 	}
++ 	if looksLikeDiff("just a message") {
++ 		t.Error("looksLikeDiff accepted plain text")
++ 	}
++ 	tr := newTranscript(80)
++ 	tr.startTool("edit_file", "path=x.go")
++ 	tr.finishTool("edit_file", diff, false)
++ 	out := tr.render()
++ 	for _, want := range []string{"-old", "+new", "@@ -1 +1 @@"} {
++ 		if !strings.Contains(out, want) {
++ 			t.Errorf("diff line %q missing from render", want)
++ 		}
++ 	}
++ 	// The ⎿ prefix belongs to summarised output, not to a diff.
++ 	if strings.Contains(out, "⎿") {
++ 		t.Error("diff was rendered through the summary path")
++ 	}
++ }
++ func TestSummarizeInputIsSorted(t *testing.T) {
++ 	in := json.RawMessage(`{"path":"x.go","limit":10,"offset":2}`)
++ 	if got, want := summarizeInput(in), "limit=10, offset=2, path=x.go"; got != want {
++ 		t.Errorf("summarizeInput = %q, want %q", got, want)
++ 	}
++ }
++ func TestSummarizeInputFlattensNewlines(t *testing.T) {
++ 	in := json.RawMessage(`{"command":"go build\ngo test"}`)
++ 	if got := summarizeInput(in); strings.Contains(got, "\n") {
++ 		t.Errorf("newline survived into the header line: %q", got)
++ 	}
++ }
++ func TestSummarizeInputHandlesGarbage(t *testing.T) {
++ 	if got := summarizeInput(json.RawMessage(`not json`)); got != "not json" {
++ 		t.Errorf("garbage input = %q, want it passed through", got)
++ 	}
++ 	if got := summarizeInput(nil); got != "" {
++ 		t.Errorf("nil input = %q, want empty", got)
++ 	}
++ }
++ func TestTruncateCountsRunesNotBytes(t *testing.T) {
++ 	// Slicing this by bytes would produce invalid UTF-8.
++ 	if got := truncate("日本語テキスト", 4); len([]rune(got)) != 4 {
++ 		t.Errorf("truncate returned %d runes, want 4 (%q)", len([]rune(got)), got)
++ 	}
++ 	if got := truncate("short", 50); got != "short" {
++ 		t.Errorf("truncate shortened a short string: %q", got)
++ 	}
++ 	if got := truncate("abc", 0); got != "" {
++ 		t.Errorf("truncate(_, 0) = %q, want empty", got)
++ 	}
++ }
++ // An approval gates a call before it runs, so it must render with the call
++ // rather than after the result that came back later.
++ func TestAnnotateToolAttachesToTheGatedCall(t *testing.T) {
++ 	tr := newTranscript(80)
++ 	tr.startTool("bash", "command=go build ./...")
++ 	tr.annotateTool("bash", "approved once")
++ 	tr.finishTool("bash", "ok", false)
++ 	if len(tr.entries) != 1 {
++ 		t.Fatalf("got %d entries, want the note folded into the call", len(tr.entries))
++ 	}
++ 	if tr.entries[0].note != "approved once" {
++ 		t.Errorf("note = %q", tr.entries[0].note)
++ 	}
++ 	out := tr.render()
++ 	note, result := strings.Index(out, "approved once"), strings.Index(out, "ok")
++ 	if note < 0 || result < 0 {
++ 		t.Fatalf("note or result missing from render:\n%s", out)
++ 	}
++ 	if note > result {
++ 		t.Error("the approval rendered after the result it gated")
++ 	}
++ }
++ func TestAnnotateToolWithoutOpenCallFallsBackToANotice(t *testing.T) {
++ 	tr := newTranscript(80)
++ 	tr.annotateTool("bash", "denied")
++ 	if len(tr.entries) != 1 || tr.entries[0].kind != entryNotice {
++ 		t.Fatalf("orphan note not recorded: %+v", tr.entries)
++ 	}
++ }
++ // Styled text measured by rune count treats every escape byte as a visible
++ // cell, which silently eats the end of a status line.
++ func TestTruncateStyledMeasuresDisplayWidth(t *testing.T) {
++ 	styled := styDim.Render("ready") + " · " + styCoral.Render("$0.0241")
++ 	plain := "ready · $0.0241"
++ 	// Compare display width against display width: len() would count the
++ 	// two-byte · as two cells and make this assertion wrong rather than strict.
++ 	if got, want := lipgloss.Width(truncateStyled(styled, 40)), lipgloss.Width(plain); got != want {
++ 		t.Errorf("width %d, want %d — styled text was cut though it fits", got, want)
++ 	}
++ 	if got := truncateStyled(styled, 40); !strings.Contains(got, "$0.0241") {
++ 		t.Errorf("cost was truncated away though it fits: %q", got)
++ 	}
++ 	if got := truncateStyled(styled, 8); lipgloss.Width(got) > 8 {
++ 		t.Errorf("width %d exceeds the limit of 8", lipgloss.Width(got))
++ 	}
++ 	if got := truncateStyled(styled, 0); got != "" {
++ 		t.Errorf("zero width = %q, want empty", got)
++ 	}
++ }
++ func TestRenderNarrowWidthDoesNotPanic(t *testing.T) {
++ 	tr := newTranscript(1)
++ 	tr.addUser("a reasonably long line that must wrap somewhere")
++ 	tr.startTool("bash", "command=echo hi")
++ 	tr.finishTool("bash", "hi", false)
++ 	tr.addError("boom")
++ 	_ = tr.render()
++ }