johannSoCodeyPublic

ask: the agent stops and asks, and you answer in a box

A coding agent that cannot ask a question has two ways to handle an ambiguous
request: guess, or stop and write a paragraph about it. Both cost a round
trip, and the guess costs the work built on it. This is the third way, the
one Claude Code calls AskUserQuestion: a tool the model calls mid-task that
puts a multiple-choice question on screen and blocks until you answer.

internal/ask owns the shape — one to four questions, two to four options
each, a header naming the decision, a description per option saying what
choosing it means — along with validation whose messages are written for the
model to read and correct, and the result format, which repeats each question
beside its answer because the model reads it many turns later.

The picker is the approval box's twin and works the same way underneath: the
agent blocks on a buffered channel, the update loop keeps running, and the
wait honours the turn's context so an interrupt cannot strand either side.
Arrows or the wheel move, digits answer outright, space ticks a box where
several answers are allowed, left goes back to change an answer, and a click
lands on the option it looks like it lands on — the hit map is what the last
frame actually drew, so an option's description is part of the option. The
last row is always free text: three options that are all wrong is a corner
the user should never be in.

A dismissal is not an answer, and is reported to the model as an error
telling it to decide for itself and say what it chose. An approval outranks a
question already on screen, since a tool call cannot start until someone says
so. A question whose turn is interrupted dies with the turn; a subagent's
does not, because it belongs to another one.

Only the session's own agent gets the tool, registered on its own registry
rather than in the shared factory: a subagent reports to its parent, and the
parent is not a person to ask. Outside the TUI the same questions are put a
line at a time, and a run with nothing on stdin gets no answer, which the
tool reports as a dismissal.

Along the way: jsonschema:"description=..." is split on commas by the
reflector, so eleven field descriptions had been reaching the model as half a
sentence — "It cannot ask you questions and it cannot see this conversation"
stopped there. All twenty-five tags move to jsonschema_description, which
takes the value whole, with a test that notices if one drifts back.

Browse Files

Jjonicommitted 4 weeks ago1 parent 7ada7cfcommit9e0d91a

Showing 26 changed files with 2091 additions and 52 deletions.

+56−3README.mdView File

@@ -190,6 +190,57 @@ Commands: `/allowed`, `/clear`, `/compact`, `/effort`, `/exit`, `/help`,
190	190	`/model`, `/mouse`, `/settings`, `/setup`, `/skills`, and one per discovered
191	191	skill.
192	192
	193	+ ### Questions
	194	+
	195	+ The agent can stop in the middle of a task and ask you something. It calls
	196	+ `ask_user`, the turn parks, and a box comes up with the options it thought of:
	197	+
	198	+ ```
	199	+ ● the agent has a question
	200	+ ╭──────────────────────────────────────────────────────────────────────────────╮
	201	+ │ Storage · question 1 of 2 │
	202	+ │ Sessions have to live somewhere once the process exits. Where should they go?│
	203	+ │ │
	204	+ │ ❯ 1. Postgres (recommended) │
	205	+ │ what the rest of the stack already runs; no new service to operate │
	206	+ │ 2. SQLite │
	207	+ │ a file on disk, and one fewer thing to have running │
	208	+ │ 3. Keep them in memory │
	209	+ │ simplest, and they are gone when you quit │
	210	+ │ 4. something else — type it yourself │
	211	+ │ │
	212	+ │ ↑↓ move · enter choose · esc skip the question │
	213	+ ╰──────────────────────────────────────────────────────────────────────────────╯
	214	+ ```
	215	+
	216	+ \| Key \| Does \|
	217	+ \| --- \| --- \|
	218	+ \| `↑`/`↓` \| move the cursor — the wheel does the same \|
	219	+ \| `1`–`9` \| answer with that option outright \|
	220	+ \| `space` \| tick a box, where the question allows several answers \|
	221	+ \| `enter` \| take the row under the cursor, or confirm what is ticked \|
	222	+ \| `←` \| back to the previous question, to change an answer \|
	223	+ \| `esc` \| skip: the agent is told to decide for itself and say what it chose \|
	224	+
	225	+ The last row is always there and always free text, so you are never cornered
	226	+ by three options that are all wrong; typing an answer is the same key as
	227	+ picking one. A click does what enter would — on the description under a label
	228	+ as well as on the label, because that is what it looks like you are clicking.
	229	+
	230	+ This is the approval box's twin, and it works the same way underneath: the
	231	+ agent blocks on a channel, the UI keeps running, and an interrupt releases it.
	232	+ Where the two collide the approval goes first — a tool call cannot start until
	233	+ someone says so, and the question is still there behind it. A question whose
	234	+ turn is interrupted goes with the turn, since the tool call waiting for the
	235	+ answer no longer exists.
	236	+
	237	+ Only the session's own agent gets the tool. A subagent's report goes to its
	238	+ parent, and the parent is not a person to ask.
	239	+
	240	+ Outside the TUI the same questions are asked a line at a time, and a run with
	241	+ nothing on stdin — a `-p` one-shot in a script — gets no answer, which the tool
	242	+ reports as a dismissal so the model decides for itself and says so.
	243	+
193	244	### The mouse
194	245
195	246	\| Does \| How \|
@@ -671,6 +722,7 @@ and any key skips the one playing.
671	722	\| `edit_file` \| prompts \| Requires a prior read; refuses ambiguous matches; returns a diff \|
672	723	\| `write_file` \| prompts \| Whole files only; separate from `edit_file` so the metrics stay honest \|
673	724	\| `bash` \| prompts \| Own process group, killed whole on timeout; output capped head and tail \|
	725	+ \| `ask_user` \| never \| Puts a multiple-choice question to you and waits — see [questions](#questions) \|
674	726
675	727	## Skills
676	728
@@ -786,6 +838,7 @@ internal/tools the tool registry and the tools
786	838	internal/skills discovery and parsing of SKILL.md
787	839	internal/config saved defaults: model, effort, approvals, theme, compaction
788	840	internal/approval allow / deny / ask, with shell analysis
	841	+ internal/ask questions the agent puts to you mid-task, and the tool for it
789	842	internal/metrics JSONL event log
790	843	internal/ui line-based terminal rendering
791	844	internal/tui full-screen Bubble Tea front end, and the setup wizard
@@ -800,6 +853,6 @@ A failed edit is a normal event in the transcript.
800	853	The TUI obeys the first rule through two one-way hatches. Events reach it via
801	854	`agent.Observe`, forwarded into the Bubble Tea loop with `Program.Send`, which
802	855	is safe from the agent's goroutine. Approvals go out the same way and then
803		- block the agent on a reply channel until a key arrives. That channel is
804		- buffered and the wait honours the turn's context, so neither side can strand
805		- the other.
	856	+ block the agent on a reply channel until a key arrives, and questions take the
	857	+ same hatch with an answer on the way back. Those channels are buffered and the
	858	+ wait honours the turn's context, so neither side can strand the other.

+10−0cmd/codey/main.goView File

@@ -16,6 +16,7 @@ import (
16	16
17	17	"codey/internal/agent"
18	18	"codey/internal/approval"
	19	+ "codey/internal/ask"
19	20	"codey/internal/claudecode"
20	21	"codey/internal/config"
21	22	"codey/internal/llm"
@@ -244,6 +245,14 @@ func run() error {
244	245	render := &ui.Renderer{W: os.Stdout, Verbose: *verbose}
245	246	approver := &ui.Approver{In: in, Out: os.Stdout}
246	247	policy := approval.New(approver.Prompt)
	248	+
	249	+ // Questions go to the line front end until a TUI takes them over in
	250	+ // tui.Run. The tool belongs to the session's own agent and is registered
	251	+ // here rather than in newTools, so a subagent still cannot stop and ask:
	252	+ // its report goes to the parent, and the parent is not a person.
	253	+ asker := ask.NewAsker((&ui.Asker{In: in, Out: os.Stdout}).Prompt)
	254	+ reg.Register(ask.Tool(asker.Ask))
	255	+
247	256	policy.YOLO = acceptAll
248	257	if acceptAll && !useTUI {
249	258	// The TUI says this itself, in the banner.
@@ -317,6 +326,7 @@ func run() error {
317	326	return tui.Run(context.Background(), tui.Options{
318	327	Agent: a,
319	328	Policy: policy,
	329	+ Asker: asker,
320	330	Client: client,
321	331	Root: root,
322	332	SessionDir: sessionDir,

+3−0internal/approval/policy.goView File

@@ -47,6 +47,9 @@ var readOnly = map[string]bool{
47	47	// skill reads one file from a directory found at startup, and cannot
48	48	// reach anything read_file could not already reach.
49	49	"skill": true,
	50	+ // ask_user changes nothing and is itself a prompt. Asking permission to
	51	+ // ask a question would be two boxes for one decision.
	52	+ "ask_user": true,
50	53	}
51	54
52	55	// Policy decides whether a tool call proceeds, remembering what it is told.

+189−0internal/ask/ask.goaddedView File

++ // Package ask is the question the agent puts to the user in the middle of a
++ // task, rather than at the end of one.
++ //
++ // It is the other half of approval. An approval asks "may I do this thing I
++ // have decided on"; a question asks "which of these should I decide on at
++ // all". Both suspend the agent on a channel until a human answers, and both
++ // reach the front end through a function the front end supplies — a TUI
++ // picker, a line of stdin, or a test — so nothing below this package knows a
++ // terminal exists.
++ //
++ // The shape is fixed rather than free: a handful of questions, a handful of
++ // labelled options each, and a way to type something that was not offered.
++ // A picker that can render anything renders nothing well, and an agent that
++ // can ask anything asks too much.
++ package ask
++ import (
++ 	"context"
++ 	"errors"
++ 	"fmt"
++ 	"strings"
++ 	"sync"
++ )
++ // The limits are the picker's, not the model's: four options fit on a screen
++ // beside their descriptions and can be reached with one digit, and a fifth
++ // question is a conversation the agent should be having in prose.
++ const (
++ 	MaxQuestions = 4
++ 	MinOptions   = 2
++ 	MaxOptions   = 4
++ )
++ // Option is one answer offered for a question.
++ type Option struct {
++ 	// Label is the answer itself, short enough to sit in a list.
++ 	Label string
++ 	// Description is the line under it: what choosing this one means. It may
++ 	// be empty, though a choice whose consequence is not stated is usually a
++ 	// choice the user cannot make.
++ 	Description string
++ }
++ // Question is one multiple-choice question.
++ type Question struct {
++ 	// Header is a word or two naming the decision, used as the label on the
++ 	// box. Long headers are truncated when drawn rather than refused.
++ 	Header string
++ 	// Question is the question in full, as a sentence.
++ 	Question string
++ 	// Options are what is offered, in the order they are offered.
++ 	Options []Option
++ 	// MultiSelect allows any number of them to be picked rather than one.
++ 	MultiSelect bool
++ }
++ // Request is one call of the ask tool: everything the agent wants to know
++ // before it carries on.
++ type Request struct {
++ 	// Agent is the subagent asking, empty for the session's own agent. The
++ 	// same field, for the same reason, as approval.Request.Agent: several
++ 	// agents share one box, and a question that does not say who is asking
++ 	// cannot be answered.
++ 	Agent     string
++ 	Questions []Question
++ }
++ // Answer is what came back for one question. Chosen holds option labels in
++ // the order they were offered; Other is text the user typed instead, which is
++ // how a question gets an answer nobody thought to offer.
++ type Answer struct {
++ 	Header   string
++ 	Question string
++ 	Chosen   []string
++ 	Other    string
++ }
++ // Response is the answer to a whole request. Dismissed says the user closed
++ // the box without answering, which is not an answer and must not be reported
++ // to the model as one.
++ type Response struct {
++ 	Answers   []Answer
++ 	Dismissed bool
++ }
++ // Prompt asks a human. Returning an error abandons the call: the tool reports
++ // the error to the model, which is what a cancelled turn looks like from the
++ // inside.
++ type Prompt func(context.Context, Request) (Response, error)
++ // Asker is the indirection between the tool and whatever can reach a human.
++ // The tool is built when the registry is, which is before any front end
++ // exists, so the front end installs itself here afterwards — the same move
++ // approval.Policy makes with its Prompt field.
++ //
++ // The lock is not ceremony: Use runs on the goroutine that starts the program
++ // and Ask runs on the agent's.
++ type Asker struct {
++ 	mu     sync.Mutex
++ 	prompt Prompt
++ }
++ // NewAsker returns an asker with a starting prompt, which may be nil.
++ func NewAsker(p Prompt) *Asker { return &Asker{prompt: p} }
++ // Use installs the prompt in force from now on.
++ func (a *Asker) Use(p Prompt) {
++ 	a.mu.Lock()
++ 	defer a.mu.Unlock()
++ 	a.prompt = p
++ }
++ // Ask implements Prompt by forwarding to whatever is installed.
++ func (a *Asker) Ask(ctx context.Context, req Request) (Response, error) {
++ 	a.mu.Lock()
++ 	p := a.prompt
++ 	a.mu.Unlock()
++ 	if p == nil {
++ 		return Response{}, errors.New("nothing in this session can reach the user")
++ 	}
++ 	return p(ctx, req)
++ }
++ // Validate checks a request the model built. Every message it returns is read
++ // by the model and has to say what to send instead, because a rejected call
++ // is one the model gets to make again.
++ func Validate(r Request) error {
++ 	switch {
++ 	case len(r.Questions) == 0:
++ 		return fmt.Errorf("no questions: send between 1 and %d", MaxQuestions)
++ 	case len(r.Questions) > MaxQuestions:
++ 		return fmt.Errorf("%d questions is too many: ask at most %d in one call, and ask the rest after these are answered",
++ 			len(r.Questions), MaxQuestions)
++ 	}
++ 	for i, q := range r.Questions {
++ 		where := fmt.Sprintf("question %d", i+1)
++ 		if strings.TrimSpace(q.Question) == "" {
++ 			return fmt.Errorf("%s has no text: say what is being decided", where)
++ 		}
++ 		if strings.TrimSpace(q.Header) == "" {
++ 			return fmt.Errorf("%s (%q) has no header: give it a word or two naming the decision", where, q.Question)
++ 		}
++ 		switch {
++ 		case len(q.Options) < MinOptions:
++ 			return fmt.Errorf("%s (%q) offers %d options: offer at least %d, or do not ask — a question with one answer is a statement",
++ 				where, q.Header, len(q.Options), MinOptions)
++ 		case len(q.Options) > MaxOptions:
++ 			return fmt.Errorf("%s (%q) offers %d options: offer at most %d, and fold the rest into the ones that matter — the user can always type something else",
++ 				where, q.Header, len(q.Options), MaxOptions)
++ 		}
++ 		seen := map[string]bool{}
++ 		for j, o := range q.Options {
++ 			label := strings.TrimSpace(o.Label)
++ 			if label == "" {
++ 				return fmt.Errorf("%s (%q) option %d has no label", where, q.Header, j+1)
++ 			}
++ 			if seen[strings.ToLower(label)] {
++ 				return fmt.Errorf("%s (%q) offers %q twice: an answer has to name one option", where, q.Header, label)
++ 			}
++ 			seen[strings.ToLower(label)] = true
++ 		}
++ 	}
++ 	return nil
++ }
++ // Format renders a response as the tool result. It repeats each question
++ // beside its answer: the model reads this many turns later, by which time
++ // "Postgres" on its own has stopped meaning anything.
++ func (r Response) Format() string {
++ 	if len(r.Answers) == 0 {
++ 		return "the user answered nothing"
++ 	}
++ 	var b strings.Builder
++ 	b.WriteString("The user answered:\n")
++ 	for _, a := range r.Answers {
++ 		fmt.Fprintf(&b, "\n%s — %s\n", a.Header, a.Question)
++ 		switch {
++ 		case a.Other != "":
++ 			// Their own words are marked as such: the agent offered three
++ 			// options and none of them is what it is about to act on.
++ 			fmt.Fprintf(&b, "  in their own words: %s\n", a.Other)
++ 		case len(a.Chosen) == 0:
++ 			b.WriteString("  (skipped)\n")
++ 		default:
++ 			fmt.Fprintf(&b, "  %s\n", strings.Join(a.Chosen, ", "))
++ 		}
++ 	}
++ 	return strings.TrimRight(b.String(), "\n")
++ }

+201−0internal/ask/ask_test.goaddedView File

++ package ask
++ import (
++ 	"context"
++ 	"encoding/json"
++ 	"errors"
++ 	"strings"
++ 	"testing"
++ )
++ func twoOptions() Question {
++ 	return Question{
++ 		Header:   "Storage",
++ 		Question: "How should sessions be stored?",
++ 		Options:  []Option{{Label: "Postgres"}, {Label: "SQLite"}},
++ 	}
++ }
++ // Every rejection is read by the model, which gets to send another call. A
++ // message that does not say what to send instead wastes that turn.
++ func TestValidateRejectsWhatCannotBeDrawn(t *testing.T) {
++ 	tooMany := Request{}
++ 	for i := 0; i < MaxQuestions+1; i++ {
++ 		tooMany.Questions = append(tooMany.Questions, twoOptions())
++ 	}
++ 	oneOption := twoOptions()
++ 	oneOption.Options = oneOption.Options[:1]
++ 	fiveOptions := twoOptions()
++ 	for i := 0; i < 4; i++ {
++ 		fiveOptions.Options = append(fiveOptions.Options, Option{Label: string(rune('a' + i))})
++ 	}
++ 	noHeader := twoOptions()
++ 	noHeader.Header = "  "
++ 	noText := twoOptions()
++ 	noText.Question = ""
++ 	dup := twoOptions()
++ 	dup.Options[1].Label = "postgres"
++ 	blank := twoOptions()
++ 	blank.Options[1].Label = ""
++ 	cases := map[string]struct {
++ 		req  Request
++ 		want string
++ 	}{
++ 		"nothing asked":   {Request{}, "1 and 4"},
++ 		"too many":        {tooMany, "at most 4"},
++ 		"one option":      {Request{Questions: []Question{oneOption}}, "at least 2"},
++ 		"five options":    {Request{Questions: []Question{fiveOptions}}, "at most 4"},
++ 		"no header":       {Request{Questions: []Question{noHeader}}, "header"},
++ 		"no question":     {Request{Questions: []Question{noText}}, "no text"},
++ 		"same label":      {Request{Questions: []Question{dup}}, "twice"},
++ 		"blank label":     {Request{Questions: []Question{blank}}, "no label"},
++ 		"a good question": {Request{Questions: []Question{twoOptions()}}, ""},
++ 	}
++ 	for name, c := range cases {
++ 		err := Validate(c.req)
++ 		switch {
++ 		case c.want == "" && err != nil:
++ 			t.Errorf("%s: rejected a valid request: %v", name, err)
++ 		case c.want == "":
++ 		case err == nil:
++ 			t.Errorf("%s: accepted", name)
++ 		case !strings.Contains(err.Error(), c.want):
++ 			t.Errorf("%s: %q does not mention %q", name, err, c.want)
++ 		}
++ 	}
++ }
++ // The model reads the result many turns later, by which time a bare label has
++ // stopped meaning anything. The question has to travel with the answer.
++ func TestFormatRepeatsTheQuestion(t *testing.T) {
++ 	got := Response{Answers: []Answer{
++ 		{Header: "Storage", Question: "How should sessions be stored?", Chosen: []string{"Postgres"}},
++ 		{Header: "Scope", Question: "What should it cover?", Chosen: []string{"the CLI", "the TUI"}},
++ 		{Header: "Naming", Question: "What should it be called?", Other: "call it sessiondir"},
++ 	}}.Format()
++ 	for _, want := range []string{
++ 		"How should sessions be stored?", "Postgres",
++ 		"the CLI, the TUI",
++ 		"in their own words: call it sessiondir",
++ 	} {
++ 		if !strings.Contains(got, want) {
++ 			t.Errorf("missing %q from:\n%s", want, got)
++ 		}
++ 	}
++ }
++ func TestAskerForwardsAndCanBeReplaced(t *testing.T) {
++ 	a := NewAsker(nil)
++ 	if _, err := a.Ask(context.Background(), Request{}); err == nil {
++ 		t.Error("an asker with nothing installed should say so rather than hang")
++ 	}
++ 	a.Use(func(context.Context, Request) (Response, error) {
++ 		return Response{Answers: []Answer{{Chosen: []string{"first"}}}}, nil
++ 	})
++ 	got, err := a.Ask(context.Background(), Request{})
++ 	if err != nil || got.Answers[0].Chosen[0] != "first" {
++ 		t.Fatalf("Ask = %+v, %v", got, err)
++ 	}
++ 	// The TUI installs itself over the line front end at startup; the tool is
++ 	// already built by then and must follow the swap.
++ 	a.Use(func(context.Context, Request) (Response, error) {
++ 		return Response{Answers: []Answer{{Chosen: []string{"second"}}}}, nil
++ 	})
++ 	if got, _ := a.Ask(context.Background(), Request{}); got.Answers[0].Chosen[0] != "second" {
++ 		t.Errorf("Ask = %+v, want the prompt installed last", got)
++ 	}
++ }
++ func TestToolAnswersTheModel(t *testing.T) {
++ 	var seen Request
++ 	tool := Tool(func(_ context.Context, r Request) (Response, error) {
++ 		seen = r
++ 		return Response{Answers: []Answer{{Header: "Storage", Question: "Where?", Chosen: []string{"Postgres"}}}}, nil
++ 	})
++ 	out, err := tool.Execute(context.Background(), json.RawMessage(`{"questions":[
++ 		{"header":"Storage","question":"Where?","options":[
++ 			{"label":"Postgres","description":"already running"},
++ 			{"label":"SQLite"}]}]}`))
++ 	if err != nil {
++ 		t.Fatalf("Execute: %v", err)
++ 	}
++ 	if !strings.Contains(out, "Postgres") {
++ 		t.Errorf("result does not carry the answer: %q", out)
++ 	}
++ 	if len(seen.Questions) != 1 || seen.Questions[0].Options[0].Description != "already running" {
++ 		t.Errorf("the prompt saw %+v", seen)
++ 	}
++ }
++ // A dismissal is not an answer, and reporting it as one would have the model
++ // act on a decision nobody made.
++ func TestToolReportsDismissalAsAnError(t *testing.T) {
++ 	tool := Tool(func(context.Context, Request) (Response, error) {
++ 		return Response{Dismissed: true}, nil
++ 	})
++ 	out, err := tool.Execute(context.Background(), json.RawMessage(`{"questions":[
++ 		{"header":"Storage","question":"Where?","options":[{"label":"a"},{"label":"b"}]}]}`))
++ 	if err == nil {
++ 		t.Fatalf("a dismissed question returned %q and no error", out)
++ 	}
++ 	if !strings.Contains(err.Error(), "pick the option you think best") {
++ 		t.Errorf("the error should say what to do instead, got %q", err)
++ 	}
++ }
++ // A call that cannot be drawn never reaches the user: the model is told to fix
++ // it while the screen is still quiet.
++ func TestToolValidatesBeforeAsking(t *testing.T) {
++ 	called := false
++ 	tool := Tool(func(context.Context, Request) (Response, error) {
++ 		called = true
++ 		return Response{}, nil
++ 	})
++ 	if _, err := tool.Execute(context.Background(), json.RawMessage(`{"questions":[
++ 		{"header":"Storage","question":"Where?","options":[{"label":"only one"}]}]}`)); err == nil {
++ 		t.Fatal("a one-option question was accepted")
++ 	}
++ 	if called {
++ 		t.Error("the user was asked a question that could not be drawn")
++ 	}
++ }
++ func TestToolWithoutAPromptSaysSoRatherThanPanicking(t *testing.T) {
++ 	_, err := Tool(nil).Execute(context.Background(), json.RawMessage(`{"questions":[
++ 		{"header":"Storage","question":"Where?","options":[{"label":"a"},{"label":"b"}]}]}`))
++ 	if err == nil {
++ 		t.Fatal("expected an error")
++ 	}
++ }
++ func TestToolPassesTheErrorFromACancelledTurn(t *testing.T) {
++ 	want := errors.New("turn cancelled")
++ 	_, err := Tool(func(context.Context, Request) (Response, error) {
++ 		return Response{}, want
++ 	}).Execute(context.Background(), json.RawMessage(`{"questions":[
++ 		{"header":"Storage","question":"Where?","options":[{"label":"a"},{"label":"b"}]}]}`))
++ 	if !errors.Is(err, want) {
++ 		t.Fatalf("err = %v, want the prompt's own error", err)
++ 	}
++ }
++ // The schema is the only thing the model sees before it calls. A field
++ // description that stops at the first comma is worse than none: it reads as a
++ // complete instruction and is half of one.
++ func TestSchemaKeepsWholeDescriptions(t *testing.T) {
++ 	schema := string(Tool(nil).InputSchema())
++ 	for _, want := range []string{
++ 		"1 to 4 of them",
++ 		"2 to 4 of them",
++ 		"the consequence, not the label again",
++ 	} {
++ 		if !strings.Contains(schema, want) {
++ 			t.Errorf("schema lost %q:\n%s", want, schema)
++ 		}
++ 	}
++ }

+118−0internal/ask/tool.goaddedView File

++ package ask
++ import (
++ 	"context"
++ 	"errors"
++ 	"fmt"
++ 	"codey/internal/tools"
++ )
++ // Name is the tool the model calls. It is snake_case like every other tool
++ // here rather than Claude Code's AskUserQuestion, because a model picks a tool
++ // by its description and the rest of this registry is named this way.
++ const Name = "ask_user"
++ // Description is deliberately more prohibition than invitation. A model that
++ // enjoys asking questions turns a five-minute task into a quiz, and the whole
++ // value of the tool is that a question means something when it arrives.
++ const Description = `Ask the user a multiple-choice question and wait for the answer.
++ Use this only when you are blocked on a decision that is genuinely theirs to
++ make: one you cannot settle from the request, from the code in front of you,
++ or from an obvious default. Ambiguity you can resolve by reading another file
++ is not a question — go and read the file. A preference about scope, risk,
++ naming, or which of several defensible designs they want is.
++ Ask at the point the decision is needed, not after you have built one of the
++ answers. Ask everything you need in one call rather than stopping the user
++ three times, and then carry on: do not ask and then ask again about the same
++ thing in different words.
++ Each question needs a short header naming the decision, the question itself,
++ and two to four options. Give every option a description saying what choosing
++ it means — the consequence, not a restatement of the label. Make the options
++ mutually exclusive, and put the one you would pick first with "(recommended)"
++ at the end of its label when you genuinely have a view. Set multi_select when
++ several answers can be true at once.
++ The user can always type an answer you did not offer, so do not add an
++ "Other" option yourself. They can also dismiss the question, which comes back
++ as an error: when it does, pick the most sensible option, say which you
++ picked, and keep going.`
++ // Tool builds the ask tool. prompt is how it reaches a human; a nil prompt
++ // means nothing can answer, and the caller should not register the tool at
++ // all rather than offering the model a tool that always fails.
++ func Tool(prompt Prompt) tools.Tool {
++ 	return tools.New(Name, Description, func(ctx context.Context, in args) (string, error) {
++ 		if prompt == nil {
++ 			return "", errors.New("there is no way to reach the user from this session. Decide it yourself and say what you assumed")
++ 		}
++ 		req := in.request()
++ 		if err := Validate(req); err != nil {
++ 			return "", err
++ 		}
++ 		resp, err := prompt(ctx, req)
++ 		if err != nil {
++ 			return "", err
++ 		}
++ 		if resp.Dismissed {
++ 			return "", errors.New("the user dismissed the question without answering. Do not ask it again: pick the option you think best, say which you picked and why, and carry on")
++ 		}
++ 		if len(resp.Answers) == 0 {
++ 			return "", errors.New("the user answered nothing. Pick the option you think best, say so, and carry on")
++ 		}
++ 		return resp.Format(), nil
++ 	})
++ }
++ // args is the wire shape. The schema is derived from these tags, so the
++ // description a model reads for each field lives here and nowhere else.
++ type args struct {
++ 	Questions []question `json:"questions" jsonschema_description:"The questions to put to the user, 1 to 4 of them. They are answered one after another in this order."`
++ }
++ type question struct {
++ 	Header      string   `json:"header" jsonschema_description:"One or two words naming the decision — 'Storage', 'Error handling'. It labels the box, so keep it under about twelve characters."`
++ 	Question    string   `json:"question" jsonschema_description:"The question itself, as a full sentence the user can answer without having read your reasoning."`
++ 	Options     []option `json:"options" jsonschema_description:"The answers offered, 2 to 4 of them. Put the one you recommend first."`
++ 	MultiSelect bool     `json:"multi_select,omitempty" jsonschema_description:"Allow several answers at once. Leave it out for a question with one right answer."`
++ }
++ type option struct {
++ 	Label       string `json:"label" jsonschema_description:"The answer, short enough to read in a list. Add ' (recommended)' to the one you would pick, if you have a view."`
++ 	Description string `json:"description,omitempty" jsonschema_description:"What choosing this one means: the consequence, not the label again."`
++ }
++ // request converts the wire shape into the domain type. The two are separate
++ // so the JSON field names are free to change without the picker knowing.
++ func (a args) request() Request {
++ 	req := Request{Questions: make([]Question, 0, len(a.Questions))}
++ 	for _, q := range a.Questions {
++ 		out := Question{
++ 			Header:      q.Header,
++ 			Question:    q.Question,
++ 			MultiSelect: q.MultiSelect,
++ 			Options:     make([]Option, 0, len(q.Options)),
++ 		}
++ 		for _, o := range q.Options {
++ 			out.Options = append(out.Options, Option{Label: o.Label, Description: o.Description})
++ 		}
++ 		req.Questions = append(req.Questions, out)
++ 	}
++ 	return req
++ }
++ // Summarize is the one-line description of a call, for a transcript that has
++ // to say what the agent asked before the answer exists.
++ func Summarize(r Request) string {
++ 	switch len(r.Questions) {
++ 	case 0:
++ 		return "ask the user"
++ 	case 1:
++ 		return r.Questions[0].Question
++ 	default:
++ 		return fmt.Sprintf("%d questions, starting with %s", len(r.Questions), r.Questions[0].Question)
++ 	}
++ }

+5−5internal/subagent/tools.goView File

@@ -10,14 +10,14 @@ import (
10	10
11	11	// spawnArgs is what the model sends to start an agent.
12	12	type spawnArgs struct {
13		- Preset string `json:"preset" jsonschema:"description=Which kind of agent to start. See the list in this tool's description."`
14		- Task string `json:"task" jsonschema:"description=The complete brief for the agent: what to do and what to report back. It cannot ask you questions and it cannot see this conversation, so everything it needs has to be in here — the paths you already know, what you have tried, what the answer should look like."`
15		- Effort string `json:"effort,omitempty" jsonschema:"description=How hard it should think: low, medium, high, xhigh or max. Low is right for mechanical work — searching, listing, reading something back; reach higher when the answer has to be right. Leave it out to use this session's level. Some models take no effort level at all, and then this is ignored and the answer says so."`
16		- Model string `json:"model,omitempty" jsonschema:"description=Which model to run it on. Pick one that suits the job — a small fast model for mechanical search, a strong one for design or code that has to be right. Leave it out to use this session's model, which is the safe answer when you do not know what this endpoint serves."`
	13	+ Preset string `json:"preset" jsonschema_description:"Which kind of agent to start. See the list in this tool's description."`
	14	+ Task string `json:"task" jsonschema_description:"The complete brief for the agent: what to do and what to report back. It cannot ask you questions and it cannot see this conversation, so everything it needs has to be in here — the paths you already know, what you have tried, what the answer should look like."`
	15	+ Effort string `json:"effort,omitempty" jsonschema_description:"How hard it should think: low, medium, high, xhigh or max. Low is right for mechanical work — searching, listing, reading something back; reach higher when the answer has to be right. Leave it out to use this session's level. Some models take no effort level at all, and then this is ignored and the answer says so."`
	16	+ Model string `json:"model,omitempty" jsonschema_description:"Which model to run it on. Pick one that suits the job — a small fast model for mechanical search, a strong one for design or code that has to be right. Leave it out to use this session's model, which is the safe answer when you do not know what this endpoint serves."`
17	17	}
18	18
19	19	type waitArgs struct {
20		- ID string `json:"id" jsonschema:"description=The agent id returned by spawn_agent, such as a1."`
	20	+ ID string `json:"id" jsonschema_description:"The agent id returned by spawn_agent, such as a1."`
21	21	}
22	22
23	23	// Tools are the tools the parent agent gets. Subagents are built from the

+2−2internal/tools/bash.goView File

@@ -89,8 +89,8 @@ func RunCommand(ctx context.Context, dir string, argv []string, timeout time.Dur
89	89
90	90	// BashArgs is the bash input.
91	91	type BashArgs struct {
92		- Command string `json:"command" jsonschema:"description=Shell command to run, from the working root"`
93		- TimeoutMS int `json:"timeout_ms,omitempty" jsonschema:"description=Timeout in milliseconds; defaults to 60000, maximum 600000"`
	92	+ Command string `json:"command" jsonschema_description:"Shell command to run, from the working root"`
	93	+ TimeoutMS int `json:"timeout_ms,omitempty" jsonschema_description:"Timeout in milliseconds; defaults to 60000, maximum 600000"`
94	94	}
95	95
96	96	// NewBash builds the bash tool.

+4−4internal/tools/edit.goView File

@@ -9,10 +9,10 @@ import (
9	9
10	10	// EditArgs is the edit_file input.
11	11	type EditArgs struct {
12		- Path string `json:"path" jsonschema:"description=Path to the file, absolute or relative to the working root"`
13		- OldStr string `json:"old_str" jsonschema:"description=Exact text to replace, including indentation. Must appear exactly once unless replace_all is set"`
14		- NewStr string `json:"new_str" jsonschema:"description=Text to replace it with. Use an empty string to delete"`
15		- ReplaceAll bool `json:"replace_all,omitempty" jsonschema:"description=Replace every occurrence instead of requiring a unique match"`
	12	+ Path string `json:"path" jsonschema_description:"Path to the file, absolute or relative to the working root"`
	13	+ OldStr string `json:"old_str" jsonschema_description:"Exact text to replace, including indentation. Must appear exactly once unless replace_all is set"`
	14	+ NewStr string `json:"new_str" jsonschema_description:"Text to replace it with. Use an empty string to delete"`
	15	+ ReplaceAll bool `json:"replace_all,omitempty" jsonschema_description:"Replace every occurrence instead of requiring a unique match"`
16	16	}
17	17
18	18	// NewEdit builds the edit_file tool. track must be the same tracker read_file

+2−2internal/tools/glob.goView File

@@ -31,8 +31,8 @@ var skipDirs = map[string]bool{
31	31
32	32	// GlobArgs is the glob input.
33	33	type GlobArgs struct {
34		- Pattern string `json:"pattern" jsonschema:"description=Glob pattern. ** matches across directories; a pattern with no slash is matched against the file name at any depth"`
35		- Path string `json:"path,omitempty" jsonschema:"description=Directory to search under; defaults to the working root"`
	34	+ Pattern string `json:"pattern" jsonschema_description:"Glob pattern. ** matches across directories; a pattern with no slash is matched against the file name at any depth"`
	35	+ Path string `json:"path,omitempty" jsonschema_description:"Directory to search under; defaults to the working root"`
36	36	}
37	37
38	38	// NewGlob builds the glob tool. extra names additional directories that may be

+4−4internal/tools/grep.goView File

@@ -49,10 +49,10 @@ func sortMatches(ms []match) {
49	49
50	50	// GrepArgs is the grep input.
51	51	type GrepArgs struct {
52		- Pattern string `json:"pattern" jsonschema:"description=Regular expression to search for"`
53		- Path string `json:"path,omitempty" jsonschema:"description=File or directory to search; defaults to the working root"`
54		- Glob string `json:"glob,omitempty" jsonschema:"description=Only search files matching this glob, e.g. *.go"`
55		- IgnoreCase bool `json:"ignore_case,omitempty" jsonschema:"description=Match case-insensitively"`
	52	+ Pattern string `json:"pattern" jsonschema_description:"Regular expression to search for"`
	53	+ Path string `json:"path,omitempty" jsonschema_description:"File or directory to search; defaults to the working root"`
	54	+ Glob string `json:"glob,omitempty" jsonschema_description:"Only search files matching this glob, e.g. *.go"`
	55	+ IgnoreCase bool `json:"ignore_case,omitempty" jsonschema_description:"Match case-insensitively"`
56	56	}
57	57
58	58	// NewGrep builds the grep tool. It shells out to ripgrep when available and

+3−3internal/tools/read.goView File

@@ -33,9 +33,9 @@ type FileTracker interface {
33	33
34	34	// ReadArgs is the read_file input.
35	35	type ReadArgs struct {
36		- Path string `json:"path" jsonschema:"description=Path to the file, absolute or relative to the working root"`
37		- Offset int `json:"offset,omitempty" jsonschema:"description=1-indexed line to start at; omit to start at the beginning"`
38		- Limit int `json:"limit,omitempty" jsonschema:"description=Maximum number of lines to return; defaults to 2000"`
	36	+ Path string `json:"path" jsonschema_description:"Path to the file, absolute or relative to the working root"`
	37	+ Offset int `json:"offset,omitempty" jsonschema_description:"1-indexed line to start at; omit to start at the beginning"`
	38	+ Limit int `json:"limit,omitempty" jsonschema_description:"Maximum number of lines to return; defaults to 2000"`
39	39	}
40	40
41	41	// NewRead builds the read_file tool. root anchors relative paths; track may be

+1−1internal/tools/registry.goView File

@@ -63,7 +63,7 @@ var reflector = &jsonschema.Reflector{
63	63	}
64	64
65	65	// SchemaFor derives a JSON Schema from T. Fields tagged omitempty are optional;
66		- // everything else is required. Descriptions come from `jsonschema:"description=..."`.
	66	+ // everything else is required. Descriptions come from `jsonschema_description:"..."`.
67	67	func SchemaFor[T any]() json.RawMessage {
68	68	var zero T
69	69	b, err := json.Marshal(reflector.Reflect(zero))

+23−2internal/tools/registry_test.goView File

@@ -12,8 +12,8 @@ import (
12	12	)
13	13
14	14	type echoArgs struct {
15		- Text string `json:"text" jsonschema:"description=Text to echo back"`
16		- Times int `json:"times,omitempty" jsonschema:"description=How many times to repeat it"`
	15	+ Text string `json:"text" jsonschema_description:"Text to echo back"`
	16	+ Times int `json:"times,omitempty" jsonschema_description:"How many times to repeat it"`
17	17	}
18	18
19	19	func echoTool(fail bool) Tool {
@@ -60,6 +60,27 @@ func TestSchemaForReflectsStructTags(t *testing.T) {
60	60	}
61	61	}
62	62
	63	+ // jsonschema:"description=..." is split on commas, so half of any sentence
	64	+ // with one in it never reached the model. jsonschema_description takes the tag
	65	+ // whole, and every tool here uses it for that reason; this is the test that
	66	+ // notices if one drifts back.
	67	+ func TestSchemaKeepsDescriptionsPastAComma(t *testing.T) {
	68	+ type args struct {
	69	+ Path string `json:"path" jsonschema_description:"Path to the file, absolute or relative to the working root"`
	70	+ }
	71	+ var got struct {
	72	+ Properties map[string]struct {
	73	+ Description string `json:"description"`
	74	+ } `json:"properties"`
	75	+ }
	76	+ if err := json.Unmarshal(SchemaFor[args](), &got); err != nil {
	77	+ t.Fatalf("schema is not valid JSON: %v", err)
	78	+ }
	79	+ if want := "Path to the file, absolute or relative to the working root"; got.Properties["path"].Description != want {
	80	+ t.Errorf("description = %q, want the whole of %q", got.Properties["path"].Description, want)
	81	+ }
	82	+ }
	83	+
63	84	func TestSchemaForNoFields(t *testing.T) {
64	85	type empty struct{}
65	86	var got map[string]any

+2−2internal/tools/skill.goView File

@@ -15,8 +15,8 @@ import (
15	15	// violation the model sees at once rather than a lookup failure it has to
16	16	// reason about.
17	17	type SkillArgs struct {
18		- Name string `json:"name" jsonschema:"description=Which skill to load"`
19		- Args string `json:"args,omitempty" jsonschema:"description=Arguments for the skill; whatever followed the skill name"`
	18	+ Name string `json:"name" jsonschema_description:"Which skill to load"`
	19	+ Args string `json:"args,omitempty" jsonschema_description:"Arguments for the skill; whatever followed the skill name"`
20	20	}
21	21
22	22	// NewSkill builds the skill tool over the skills discovered at startup. It

+2−2internal/tools/write.goView File

@@ -10,8 +10,8 @@ import (
10	10
11	11	// WriteArgs is the write_file input.
12	12	type WriteArgs struct {
13		- Path string `json:"path" jsonschema:"description=Path to write, absolute or relative to the working root"`
14		- Content string `json:"content" jsonschema:"description=Full contents of the file"`
	13	+ Path string `json:"path" jsonschema_description:"Path to write, absolute or relative to the working root"`
	14	+ Content string `json:"content" jsonschema_description:"Full contents of the file"`
15	15	}
16	16
17	17	// NewWrite builds the write_file tool. It is kept separate from edit_file so

+474−0internal/tui/ask.goaddedView File

++ package tui
++ // The question box is the approval box's twin: the agent is blocked on a
++ // channel, the update loop keeps running, and a keypress is what lets it go.
++ // What differs is the shape of the answer. An approval has four fixed choices
++ // and the same four every time; a question has whatever options the model
++ // thought of, sometimes several questions in a row, and always the option of
++ // typing something nobody offered.
++ //
++ // The working state lives in askState rather than in a handful of fields on
++ // the model, because there can be a queue of these and each one carries its
++ // own half-finished answers.
++ import (
++ 	"fmt"
++ 	"strings"
++ 	"github.com/charmbracelet/bubbles/textarea"
++ 	"github.com/charmbracelet/bubbles/textinput"
++ 	tea "github.com/charmbracelet/bubbletea"
++ 	"codey/internal/ask"
++ )
++ // askState is one question box: what was asked, where the cursor is, what has
++ // been ticked so far, and the channel the agent is waiting on.
++ type askState struct {
++ 	req   ask.Request
++ 	reply chan<- ask.Response
++ 	// q is which question of the request is on screen, idx the row the cursor
++ 	// is on. picked and other are per question and survive going back: an
++ 	// answer you changed your mind about twice should still be there.
++ 	q      int
++ 	idx    int
++ 	picked []map[int]bool
++ 	other  []string
++ 	// typing is the free-text field, open over the list.
++ 	typing bool
++ 	input  textinput.Model
++ 	// hit maps a row inside the box to the option drawn on it. A click is
++ 	// resolved against what was drawn rather than against an assumed row
++ 	// height, because an option with a description takes two rows and one
++ 	// without takes one.
++ 	hit map[int]int
++ }
++ func newAskState(req ask.Request, reply chan<- ask.Response) *askState {
++ 	in := textinput.New()
++ 	in.Prompt = "› "
++ 	in.Placeholder = "an answer of your own"
++ 	in.CharLimit = 0
++ 	s := &askState{
++ 		req:    req,
++ 		reply:  reply,
++ 		picked: make([]map[int]bool, len(req.Questions)),
++ 		other:  make([]string, len(req.Questions)),
++ 		input:  in,
++ 		hit:    map[int]int{},
++ 	}
++ 	for i := range s.picked {
++ 		s.picked[i] = map[int]bool{}
++ 	}
++ 	return s
++ }
++ func (s *askState) question() ask.Question { return s.req.Questions[s.q] }
++ // otherRow is the last row of the list: the way to answer something nobody
++ // offered. It is always there, which is why the tool tells the model not to
++ // write an "Other" option of its own.
++ func (s *askState) otherRow() int { return len(s.question().Options) }
++ func (s *askState) rows() int { return s.otherRow() + 1 }
++ // move walks the list, wrapping. A list this short is a ring: pressing down
++ // on the last row to get back to the first is quicker than finding ↑.
++ func (s *askState) move(step int) {
++ 	n := s.rows()
++ 	s.idx = (s.idx + step + n) % n
++ }
++ // tick marks an option. In a single-answer question it is the answer, so
++ // anything else ticked stops being it.
++ func (s *askState) tick(i int) {
++ 	if !s.question().MultiSelect {
++ 		s.picked[s.q] = map[int]bool{}
++ 	}
++ 	s.picked[s.q][i] = true
++ }
++ func (s *askState) toggle(i int) {
++ 	if s.picked[s.q][i] {
++ 		delete(s.picked[s.q], i)
++ 		return
++ 	}
++ 	s.tick(i)
++ }
++ // cursorHome is where the cursor sits when a question comes up: on the answer
++ // already given, when there is one, so going back to change your mind starts
++ // at the thing you are changing rather than at the top of the list.
++ func (s *askState) cursorHome() int {
++ 	if strings.TrimSpace(s.other[s.q]) != "" {
++ 		return s.otherRow()
++ 	}
++ 	for i := range s.question().Options {
++ 		if s.picked[s.q][i] {
++ 			return i
++ 		}
++ 	}
++ 	return 0
++ }
++ func (s *askState) anyPicked() bool {
++ 	return len(s.picked[s.q]) > 0 || strings.TrimSpace(s.other[s.q]) != ""
++ }
++ // answers is the response, in the order the questions were asked.
++ func (s *askState) answers() []ask.Answer {
++ 	out := make([]ask.Answer, 0, len(s.req.Questions))
++ 	for i, q := range s.req.Questions {
++ 		a := ask.Answer{Header: q.Header, Question: q.Question, Other: strings.TrimSpace(s.other[i])}
++ 		for j, o := range q.Options {
++ 			if s.picked[i][j] {
++ 				a.Chosen = append(a.Chosen, o.Label)
++ 			}
++ 		}
++ 		out = append(out, a)
++ 	}
++ 	return out
++ }
++ // summary is what the transcript records against the call: the answers, short
++ // enough for one line, so scrolling back says what was decided without
++ // reopening the tool result.
++ func (s *askState) summary() string {
++ 	parts := make([]string, 0, len(s.req.Questions))
++ 	for _, a := range s.answers() {
++ 		switch {
++ 		case a.Other != "":
++ 			parts = append(parts, truncate(a.Other, 40))
++ 		case len(a.Chosen) > 0:
++ 			parts = append(parts, strings.Join(a.Chosen, " + "))
++ 		}
++ 	}
++ 	if len(parts) == 0 {
++ 		return "answered"
++ 	}
++ 	return "answered: " + strings.Join(parts, " · ")
++ }
++ // ---- keys ---------------------------------------------------------------
++ func (m *model) onAskKey(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
++ 	if len(m.asking) == 0 {
++ 		m.phase = m.afterModal()
++ 		return m, nil
++ 	}
++ 	s := m.asking[0]
++ 	// ctrl-c abandons the question and the turn it belongs to, the way it
++ 	// does at an approval. A question nobody answered is not an answer, so
++ 	// the tool is told it was dismissed rather than handed an empty one.
++ 	if msg.String() == "ctrl+c" {
++ 		cmd := m.dismissAsk()
++ 		if m.phase == phaseRunning {
++ 			return m, tea.Batch(m.interrupt(), cmd)
++ 		}
++ 		return m, cmd
++ 	}
++ 	if s.typing {
++ 		return m, m.askTypingKey(s, msg)
++ 	}
++ 	switch key := msg.String(); key {
++ 	case "up", "k", "shift+tab":
++ 		s.move(-1)
++ 	case "down", "j", "tab":
++ 		s.move(1)
++ 	case "home":
++ 		s.idx = 0
++ 	case "end":
++ 		s.idx = s.rows() - 1
++ 	case " ":
++ 		// Space ticks a box. In a one-answer question there is no difference
++ 		// between ticking and answering, so it answers.
++ 		if s.idx == s.otherRow() {
++ 			return m, m.openAskInput(s)
++ 		}
++ 		if !s.question().MultiSelect {
++ 			return m, m.chooseAsk(s, s.idx)
++ 		}
++ 		s.toggle(s.idx)
++ 	case "enter":
++ 		return m, m.activateAsk(s)
++ 	case "left", "backspace":
++ 		// Back to the question before this one, to change an answer already
++ 		// given. At the first question there is nothing behind it.
++ 		if s.q > 0 {
++ 			s.q--
++ 			s.idx = s.cursorHome()
++ 		}
++ 	case "right":
++ 		// Forward only where an answer exists: skipping ahead would leave a
++ 		// question behind with nothing in it.
++ 		if s.q < len(s.req.Questions)-1 && s.anyPicked() {
++ 			s.q++
++ 			s.idx = s.cursorHome()
++ 		}
++ 	case "esc":
++ 		return m, m.dismissAsk()
++ 	default:
++ 		// A digit picks that row outright, including the last one, which is
++ 		// the way to type an answer without reaching for the arrows.
++ 		if len(key) == 1 && key[0] >= '1' && key[0] <= '9' {
++ 			if i := int(key[0] - '1'); i < s.rows() {
++ 				s.idx = i
++ 				return m, m.activateAsk(s)
++ 			}
++ 		}
++ 	}
++ 	return m, m.sync()
++ }
++ // activateAsk is enter: take the row under the cursor, or — in a question
++ // that allows several answers and already has some — take what is ticked.
++ func (m *model) activateAsk(s *askState) tea.Cmd {
++ 	if s.idx == s.otherRow() {
++ 		return m.openAskInput(s)
++ 	}
++ 	if s.question().MultiSelect {
++ 		// Enter on a question with nothing ticked means the row you are on:
++ 		// pressing space first and then enter is a ceremony nobody wants for
++ 		// a single answer to a question that merely allowed several.
++ 		if len(s.picked[s.q]) == 0 {
++ 			s.tick(s.idx)
++ 		}
++ 		return m.advanceAsk(s)
++ 	}
++ 	return m.chooseAsk(s, s.idx)
++ }
++ // chooseAsk answers a one-answer question and moves on.
++ func (m *model) chooseAsk(s *askState, i int) tea.Cmd {
++ 	s.other[s.q] = ""
++ 	s.tick(i)
++ 	return m.advanceAsk(s)
++ }
++ // openAskInput opens the free-text field, holding whatever was typed there
++ // before so that going back and forth does not lose it.
++ func (m *model) openAskInput(s *askState) tea.Cmd {
++ 	s.typing = true
++ 	s.input.SetValue(s.other[s.q])
++ 	s.input.CursorEnd()
++ 	return tea.Batch(s.input.Focus(), m.sync())
++ }
++ func (m *model) askTypingKey(s *askState, msg tea.KeyMsg) tea.Cmd {
++ 	switch msg.String() {
++ 	case "enter":
++ 		text := strings.TrimSpace(s.input.Value())
++ 		if text == "" {
++ 			// An empty answer is not an answer; the options are still there.
++ 			s.typing = false
++ 			s.input.Blur()
++ 			return m.sync()
++ 		}
++ 		s.other[s.q] = text
++ 		s.typing = false
++ 		s.input.Blur()
++ 		if !s.question().MultiSelect {
++ 			// Typed instead of chosen: a one-answer question cannot be both.
++ 			s.picked[s.q] = map[int]bool{}
++ 		}
++ 		return m.advanceAsk(s)
++ 	case "esc":
++ 		s.typing = false
++ 		s.input.Blur()
++ 		return m.sync()
++ 	}
++ 	var cmd tea.Cmd
++ 	s.input, cmd = s.input.Update(msg)
++ 	return tea.Batch(cmd, m.sync())
++ }
++ // advanceAsk moves to the next question, or answers the request when that was
++ // the last one.
++ func (m *model) advanceAsk(s *askState) tea.Cmd {
++ 	if s.q < len(s.req.Questions)-1 {
++ 		s.q++
++ 		s.idx = s.cursorHome()
++ 		return m.sync()
++ 	}
++ 	return m.submitAsk(s)
++ }
++ func (m *model) submitAsk(s *askState) tea.Cmd {
++ 	s.reply <- ask.Response{Answers: s.answers()}
++ 	note := s.summary()
++ 	m.popAsk()
++ 	m.tr.annotateTool(ask.Name, note)
++ 	return tea.Batch(m.sync(), m.spin.Tick, textarea.Blink)
++ }
++ // dismissAsk closes the box without an answer. The tool turns that into an
++ // error telling the model to decide for itself and say what it decided, which
++ // is the only honest thing to do with a question nobody answered.
++ func (m *model) dismissAsk() tea.Cmd {
++ 	if len(m.asking) == 0 {
++ 		return nil
++ 	}
++ 	m.asking[0].reply <- ask.Response{Dismissed: true}
++ 	m.popAsk()
++ 	m.tr.annotateTool(ask.Name, "dismissed")
++ 	return tea.Batch(m.sync(), m.spin.Tick, textarea.Blink)
++ }
++ // popAsk drops the answered question and puts the session back wherever it
++ // should be: at the next thing waiting, or at what it was doing before.
++ func (m *model) popAsk() {
++ 	m.asking = m.asking[1:]
++ 	m.phase = m.afterModal()
++ }
++ // ---- view ---------------------------------------------------------------
++ func (m *model) askView() string {
++ 	s := m.asking[0]
++ 	q := s.question()
++ 	width := maxInt(20, m.mainWidth()-2)
++ 	inner := maxInt(10, width-4)
++ 	var b strings.Builder
++ 	row := 0
++ 	put := func(text string) {
++ 		b.WriteString(text + "\n")
++ 		row += strings.Count(text, "\n") + 1
++ 	}
++ 	put(m.askHead(s))
++ 	put(styText.Render(wrapText(q.Question, inner)))
++ 	put("")
++ 	s.hit = map[int]int{}
++ 	if s.typing {
++ 		// Sized here rather than when it opened, so a terminal resized
++ 		// mid-answer does not leave the field the width it used to be.
++ 		s.input.Width = maxInt(8, inner-4)
++ 		put(s.input.View())
++ 		put("")
++ 		put(styFaint.Render("enter to answer · esc for the options"))
++ 		return styModal.Width(width - 2).Render(strings.TrimRight(b.String(), "\n"))
++ 	}
++ 	for i, o := range q.Options {
++ 		s.hit[row] = i
++ 		put(m.askOption(s, i, o, inner))
++ 		if o.Description != "" {
++ 			s.hit[row] = i
++ 			put(styFaint.Render(truncate("      "+o.Description, inner)))
++ 		}
++ 	}
++ 	s.hit[row] = s.otherRow()
++ 	put(m.askOther(s, inner))
++ 	put("")
++ 	put(styFaint.Render(askKeys(s)))
++ 	return styModal.Width(width - 2).Render(strings.TrimRight(b.String(), "\n"))
++ }
++ // askHead names the decision and says where in the request it is. When a
++ // subagent is asking it says which one, for the same reason the approval box
++ // does: several agents share this box.
++ func (m *model) askHead(s *askState) string {
++ 	head := styHeading.Render(strings.TrimSpace(s.question().Header))
++ 	if s.req.Agent != "" {
++ 		who := s.req.Agent
++ 		if info, ok := m.agentInfo(s.req.Agent); ok {
++ 			who += " (" + info.Preset + ")"
++ 		}
++ 		head = styCoral.Render(who) + styDim.Render(" · ") + head
++ 	}
++ 	if n := len(s.req.Questions); n > 1 {
++ 		head += styDim.Render(fmt.Sprintf(" · question %d of %d", s.q+1, n))
++ 	}
++ 	return head
++ }
++ // askOption is one row of the list: the cursor, the number to press, a box
++ // when several answers are allowed, and the label.
++ func (m *model) askOption(s *askState, i int, o ask.Option, inner int) string {
++ 	marker := "  "
++ 	label := styText.Render(o.Label)
++ 	if i == s.idx {
++ 		marker = styKey.Render("❯ ")
++ 		label = styKey.Render(o.Label)
++ 	}
++ 	box := ""
++ 	if s.question().MultiSelect {
++ 		box = "◻ "
++ 		if s.picked[s.q][i] {
++ 			box = styOK.Render("◼ ")
++ 		}
++ 	} else if s.picked[s.q][i] {
++ 		// A single-answer question only shows a tick when you have been here
++ 		// before: the answer you gave last time is the one you are changing.
++ 		box = styOK.Render("✓ ")
++ 	}
++ 	return truncateStyled(marker+styDim.Render(fmt.Sprint(i+1)+". ")+box+label, inner)
++ }
++ func (m *model) askOther(s *askState, inner int) string {
++ 	marker := "  "
++ 	text := styDim.Render("something else — type it yourself")
++ 	if s.idx == s.otherRow() {
++ 		marker = styKey.Render("❯ ")
++ 		text = styKey.Render("something else — type it yourself")
++ 	}
++ 	if got := strings.TrimSpace(s.other[s.q]); got != "" {
++ 		text = styOK.Render("✓ ") + styText.Render(truncate(got, maxInt(10, inner-12)))
++ 	}
++ 	return truncateStyled(marker+styDim.Render(fmt.Sprint(s.otherRow()+1)+". ")+text, inner)
++ }
++ func askKeys(s *askState) string {
++ 	keys := "↑↓ move · enter choose"
++ 	if s.question().MultiSelect {
++ 		keys = "↑↓ move · space tick · enter confirm"
++ 	}
++ 	if s.q > 0 {
++ 		keys += " · ← back"
++ 	}
++ 	return keys + " · esc skip the question"
++ }
++ // wrapText folds a sentence to a width. The question is the one part of the
++ // box that is prose and the one part that must not be cut off: an option can
++ // be truncated and still be recognisable, a half a question cannot be
++ // answered.
++ func wrapText(text string, width int) string {
++ 	width = maxInt(10, width)
++ 	var out []string
++ 	for _, para := range strings.Split(strings.TrimSpace(text), "\n") {
++ 		line := ""
++ 		for _, word := range strings.Fields(para) {
++ 			switch {
++ 			case line == "":
++ 				line = word
++ 			case len(line)+1+len(word) <= width:
++ 				line += " " + word
++ 			default:
++ 				out = append(out, line)
++ 				line = word
++ 			}
++ 		}
++ 		out = append(out, line)
++ 	}
++ 	return strings.Join(out, "\n")
++ }

+466−0internal/tui/ask_test.goaddedView File

++ package tui
++ import (
++ 	"strings"
++ 	"testing"
++ 	tea "github.com/charmbracelet/bubbletea"
++ 	"github.com/charmbracelet/lipgloss"
++ 	"codey/internal/approval"
++ 	"codey/internal/ask"
++ )
++ // question queues a question the way the bridge would and returns the channel
++ // the model is expected to answer on.
++ func question(m *model, req ask.Request) chan ask.Response {
++ 	reply := make(chan ask.Response, 1)
++ 	m.Update(askMsg{req: req, reply: reply})
++ 	return reply
++ }
++ func oneQuestion() ask.Request {
++ 	return ask.Request{Questions: []ask.Question{{
++ 		Header:   "Storage",
++ 		Question: "How should sessions be stored?",
++ 		Options: []ask.Option{
++ 			{Label: "Postgres", Description: "what the rest of the stack runs"},
++ 			{Label: "SQLite", Description: "no new service to operate"},
++ 		},
++ 	}}}
++ }
++ // answered reads the reply the model should have sent. A question that leaves
++ // nothing on the channel has stranded the agent, which is the failure this
++ // whole mechanism exists to avoid.
++ func answered(t *testing.T, reply chan ask.Response) ask.Response {
++ 	t.Helper()
++ 	select {
++ 	case r := <-reply:
++ 		return r
++ 	default:
++ 		t.Fatal("no answer was sent: the agent is still blocked on the channel")
++ 		return ask.Response{}
++ 	}
++ }
++ func TestAskPutsTheQuestionOnScreen(t *testing.T) {
++ 	m := newTestModel(t)
++ 	question(m, oneQuestion())
++ 	if m.phase != phaseAsking {
++ 		t.Fatalf("phase = %v, want phaseAsking", m.phase)
++ 	}
++ 	out := plain(m.askView())
++ 	for _, want := range []string{"Storage", "How should sessions be stored?", "Postgres", "SQLite", "something else"} {
++ 		if !strings.Contains(out, want) {
++ 			t.Errorf("the box does not show %q:\n%s", want, out)
++ 		}
++ 	}
++ 	if !strings.Contains(plain(m.activity()), "question") {
++ 		t.Errorf("the activity line should say a question is waiting, got %q", plain(m.activity()))
++ 	}
++ }
++ func TestAskEnterChoosesTheRowUnderTheCursor(t *testing.T) {
++ 	m := newTestModel(t)
++ 	reply := question(m, oneQuestion())
++ 	m.Update(key("down"))
++ 	m.Update(key("enter"))
++ 	got := answered(t, reply)
++ 	if got.Dismissed {
++ 		t.Fatal("choosing an option is not a dismissal")
++ 	}
++ 	if len(got.Answers) != 1 || len(got.Answers[0].Chosen) != 1 || got.Answers[0].Chosen[0] != "SQLite" {
++ 		t.Fatalf("answers = %+v, want the second option", got.Answers)
++ 	}
++ 	if got.Answers[0].Question != "How should sessions be stored?" {
++ 		t.Error("the answer should carry the question, so the model reads it in context")
++ 	}
++ 	if m.phase == phaseAsking {
++ 		t.Error("the box should be gone once it is answered")
++ 	}
++ }
++ // A digit is the quick way to answer, and it must mean the same thing as
++ // walking to that row and pressing enter.
++ func TestAskDigitAnswersOutright(t *testing.T) {
++ 	m := newTestModel(t)
++ 	reply := question(m, oneQuestion())
++ 	m.Update(key("1"))
++ 	got := answered(t, reply)
++ 	if len(got.Answers) != 1 || len(got.Answers[0].Chosen) != 1 || got.Answers[0].Chosen[0] != "Postgres" {
++ 		t.Fatalf("answers = %+v, want the first option", got.Answers)
++ 	}
++ }
++ // A digit past the end of the list is not a row. It must not answer anything,
++ // because the option it would land on does not exist.
++ func TestAskIgnoresADigitPastTheList(t *testing.T) {
++ 	m := newTestModel(t)
++ 	reply := question(m, oneQuestion())
++ 	m.Update(key("9"))
++ 	select {
++ 	case r := <-reply:
++ 		t.Fatalf("9 answered the question with %+v", r)
++ 	default:
++ 	}
++ }
++ func TestAskEscDismisses(t *testing.T) {
++ 	m := newTestModel(t)
++ 	reply := question(m, oneQuestion())
++ 	m.Update(key("esc"))
++ 	got := answered(t, reply)
++ 	if !got.Dismissed {
++ 		t.Fatal("esc should report a dismissal, not an empty answer")
++ 	}
++ 	if m.phase == phaseAsking {
++ 		t.Error("the box should be gone")
++ 	}
++ 	if !strings.Contains(plain(m.tr.render()), "dismissed") {
++ 		t.Error("the transcript should record that the question went unanswered")
++ 	}
++ }
++ // The last row is always there and is how an answer nobody offered gets in.
++ func TestAskTypesAnAnswerOfYourOwn(t *testing.T) {
++ 	m := newTestModel(t)
++ 	reply := question(m, oneQuestion())
++ 	m.Update(key("3")) // the "something else" row
++ 	if !m.asking[0].typing {
++ 		t.Fatal("the free-text field should be open")
++ 	}
++ 	if !strings.Contains(plain(m.askView()), "esc for the options") {
++ 		t.Error("the box should say how to get back to the list")
++ 	}
++ 	typeIn(m, "neither: keep it in memory")
++ 	m.Update(key("enter"))
++ 	got := answered(t, reply)
++ 	if got.Answers[0].Other != "neither: keep it in memory" {
++ 		t.Fatalf("Other = %q, want what was typed", got.Answers[0].Other)
++ 	}
++ 	if len(got.Answers[0].Chosen) != 0 {
++ 		t.Error("a typed answer to a one-answer question replaces the options rather than joining them")
++ 	}
++ }
++ // Enter on an empty free-text field is not an answer: it puts the options
++ // back rather than sending nothing.
++ func TestAskEmptyFreeTextReturnsToTheOptions(t *testing.T) {
++ 	m := newTestModel(t)
++ 	reply := question(m, oneQuestion())
++ 	m.Update(key("3"))
++ 	m.Update(key("enter"))
++ 	if m.asking[0].typing {
++ 		t.Error("the field should have closed")
++ 	}
++ 	select {
++ 	case r := <-reply:
++ 		t.Fatalf("an empty field answered the question with %+v", r)
++ 	default:
++ 	}
++ }
++ func TestAskMultiSelectTicksSeveral(t *testing.T) {
++ 	m := newTestModel(t)
++ 	reply := question(m, ask.Request{Questions: []ask.Question{{
++ 		Header:      "Scope",
++ 		Question:    "What should the change cover?",
++ 		MultiSelect: true,
++ 		Options:     []ask.Option{{Label: "the CLI"}, {Label: "the TUI"}, {Label: "the docs"}},
++ 	}}})
++ 	m.Update(key(" ")) // tick the CLI
++ 	m.Update(key("down"))
++ 	m.Update(key(" ")) // tick the TUI
++ 	m.Update(key("enter"))
++ 	got := answered(t, reply)
++ 	if want := []string{"the CLI", "the TUI"}; strings.Join(got.Answers[0].Chosen, ",") != strings.Join(want, ",") {
++ 		t.Fatalf("chosen = %v, want %v", got.Answers[0].Chosen, want)
++ 	}
++ }
++ // Enter with nothing ticked takes the row you are on. Requiring space first
++ // would be a ceremony for the common case of one answer.
++ func TestAskMultiSelectEnterTakesTheCursorRow(t *testing.T) {
++ 	m := newTestModel(t)
++ 	reply := question(m, ask.Request{Questions: []ask.Question{{
++ 		Header:      "Scope",
++ 		Question:    "What should the change cover?",
++ 		MultiSelect: true,
++ 		Options:     []ask.Option{{Label: "the CLI"}, {Label: "the TUI"}},
++ 	}}})
++ 	m.Update(key("down"))
++ 	m.Update(key("enter"))
++ 	got := answered(t, reply)
++ 	if len(got.Answers[0].Chosen) != 1 || got.Answers[0].Chosen[0] != "the TUI" {
++ 		t.Fatalf("chosen = %v, want the row the cursor was on", got.Answers[0].Chosen)
++ 	}
++ }
++ func TestAskWalksSeveralQuestionsAndGoesBack(t *testing.T) {
++ 	m := newTestModel(t)
++ 	reply := question(m, ask.Request{Questions: []ask.Question{
++ 		{Header: "Storage", Question: "Where?", Options: []ask.Option{{Label: "Postgres"}, {Label: "SQLite"}}},
++ 		{Header: "Tests", Question: "How far?", Options: []ask.Option{{Label: "unit"}, {Label: "end to end"}}},
++ 	}})
++ 	if !strings.Contains(plain(m.askView()), "question 1 of 2") {
++ 		t.Error("a request with several questions should say where in it you are")
++ 	}
++ 	m.Update(key("1")) // Postgres, on to the second question
++ 	select {
++ 	case <-reply:
++ 		t.Fatal("the request was answered before the second question was")
++ 	default:
++ 	}
++ 	if m.asking[0].q != 1 {
++ 		t.Fatalf("q = %d, want the second question", m.asking[0].q)
++ 	}
++ 	// Back to the first, change the answer, forward again.
++ 	m.Update(key("left"))
++ 	if m.asking[0].q != 0 {
++ 		t.Fatal("left should go back to the previous question")
++ 	}
++ 	m.Update(key("2")) // SQLite this time
++ 	m.Update(key("1")) // unit tests
++ 	got := answered(t, reply)
++ 	if len(got.Answers) != 2 {
++ 		t.Fatalf("got %d answers, want one per question", len(got.Answers))
++ 	}
++ 	if got.Answers[0].Chosen[0] != "SQLite" {
++ 		t.Errorf("answer 1 = %v, want the changed answer", got.Answers[0].Chosen)
++ 	}
++ 	if got.Answers[1].Chosen[0] != "unit" {
++ 		t.Errorf("answer 2 = %v", got.Answers[1].Chosen)
++ 	}
++ }
++ // An approval and a question can be waiting at once — a subagent raises one
++ // while the session's agent has asked the other. The approval goes first,
++ // and answering it must reveal the question rather than the prompt box.
++ func TestAskWaitsBehindAnApproval(t *testing.T) {
++ 	m := newTestModel(t)
++ 	reply := question(m, oneQuestion())
++ 	pend(m, approval.Request{Tool: "bash", Summary: "run a shell command", Detail: "go test ./...", Rememberable: true})
++ 	if m.phase != phaseApproving {
++ 		t.Fatalf("phase = %v, want the approval to be on top", m.phase)
++ 	}
++ 	m.Update(key("y"))
++ 	if m.phase != phaseAsking {
++ 		t.Fatalf("phase = %v, want the question back on screen", m.phase)
++ 	}
++ 	m.Update(key("1"))
++ 	answered(t, reply)
++ 	if m.phase != phaseIdle {
++ 		t.Errorf("phase = %v, want the session back where it started", m.phase)
++ 	}
++ }
++ // The tool call that asked is part of the turn. When the turn ends without
++ // it, nobody is left to read the answer, so the question goes with it.
++ func TestAskIsDroppedWhenTheTurnEnds(t *testing.T) {
++ 	m := newTestModel(t)
++ 	reply := question(m, oneQuestion())
++ 	m.Update(turnDone{})
++ 	got := answered(t, reply)
++ 	if !got.Dismissed {
++ 		t.Fatal("a question whose turn ended is dismissed, not answered")
++ 	}
++ 	if m.phase == phaseAsking {
++ 		t.Errorf("phase = %v, want the box gone with the turn", m.phase)
++ 	}
++ }
++ // A subagent's question belongs to its own turn, which the session's turn
++ // ending says nothing about.
++ func TestAskFromASubagentSurvivesTheTurn(t *testing.T) {
++ 	m := newTestModel(t)
++ 	req := oneQuestion()
++ 	req.Agent = "a1"
++ 	reply := question(m, req)
++ 	m.Update(turnDone{})
++ 	select {
++ 	case r := <-reply:
++ 		t.Fatalf("the subagent's question was dropped with the session's turn: %+v", r)
++ 	default:
++ 	}
++ 	if m.phase != phaseAsking {
++ 		t.Errorf("phase = %v, want the question still up", m.phase)
++ 	}
++ 	if !strings.Contains(plain(m.askView()), "a1") {
++ 		t.Error("the box should say which agent is asking")
++ 	}
++ }
++ // A click on an option is a choice, the way it is everywhere else in the
++ // chrome — including a click on the description under the label.
++ func TestAskClickChooses(t *testing.T) {
++ 	m := newTestModel(t)
++ 	reply := question(m, oneQuestion())
++ 	m.mouseOn = true
++ 	// The row is found in the frame rather than counted from a constant: the
++ 	// point of the test is that the hit map agrees with what was drawn, and
++ 	// arithmetic repeated here could be wrong in exactly the same way.
++ 	secs := m.layout()
++ 	row := m.height - rowsOf(secs)
++ 	for _, s := range secs {
++ 		if s.kind == secAsk {
++ 			break
++ 		}
++ 		row += lipgloss.Height(s.text)
++ 	}
++ 	for i, line := range strings.Split(plain(m.askView()), "\n") {
++ 		if strings.Contains(line, "what the rest of the stack runs") {
++ 			row += i
++ 			break
++ 		}
++ 	}
++ 	m.Update(tea.MouseMsg{Action: tea.MouseActionPress, Button: tea.MouseButtonLeft, X: 4, Y: row})
++ 	got := answered(t, reply)
++ 	if len(got.Answers[0].Chosen) != 1 || got.Answers[0].Chosen[0] != "Postgres" {
++ 		t.Fatalf("chosen = %v, want the option whose description was clicked", got.Answers[0].Chosen)
++ 	}
++ }
++ func TestAskWheelMovesTheCursorWithoutAnswering(t *testing.T) {
++ 	m := newTestModel(t)
++ 	reply := question(m, oneQuestion())
++ 	m.mouseOn = true
++ 	m.Update(tea.MouseMsg{Action: tea.MouseActionPress, Button: tea.MouseButtonWheelDown, X: 4, Y: m.height - 3})
++ 	select {
++ 	case r := <-reply:
++ 		t.Fatalf("the wheel answered the question with %+v", r)
++ 	default:
++ 	}
++ 	if m.asking[0].idx == 0 {
++ 		t.Error("the wheel should have moved the cursor")
++ 	}
++ }
++ func TestAskWrapsTheQuestionRatherThanCuttingIt(t *testing.T) {
++ 	long := "Should the retry live in the client where every call gets it or in the caller where only the ones that need it pay for it?"
++ 	got := wrapText(long, 40)
++ 	for _, line := range strings.Split(got, "\n") {
++ 		if len(line) > 40 {
++ 			t.Fatalf("line of %d columns: %q", len(line), line)
++ 		}
++ 	}
++ 	if strings.Join(strings.Fields(got), " ") != long {
++ 		t.Error("wrapping must not lose or add words")
++ 	}
++ }
++ // The box is chrome, and chrome that draws past the edge of the terminal
++ // smears the frame. The model writes the labels, so their length is not
++ // something this side gets to assume anything about.
++ func TestAskBoxFitsTheTerminal(t *testing.T) {
++ 	long := ask.Request{Questions: []ask.Question{{
++ 		Header:   "A header nobody should have written this long",
++ 		Question: "Sessions have to live somewhere once the process exits, and the answer decides what has to be running before Codey will start at all. Where should they go?",
++ 		Options: []ask.Option{
++ 			{Label: "Postgres (recommended)", Description: "what the rest of the stack already runs, so there is no new service to operate or back up"},
++ 			{Label: "SQLite", Description: "a file on disk"},
++ 		},
++ 	}}}
++ 	for _, width := range []int{24, 40, 60, 100} {
++ 		m := newTestModel(t)
++ 		m.Update(tea.WindowSizeMsg{Width: width, Height: 24})
++ 		question(m, long)
++ 		for _, state := range []string{"list", "typing"} {
++ 			if state == "typing" {
++ 				m.Update(key("3"))
++ 			}
++ 			for _, line := range strings.Split(m.askView(), "\n") {
++ 				if w := lipgloss.Width(line); w > width {
++ 					t.Errorf("at width %d the %s box drew %d cells: %q", width, state, w, plain(line))
++ 				}
++ 			}
++ 		}
++ 	}
++ }
++ // ctrl-c at a question abandons the question and the turn it belongs to: the
++ // answer would go to a tool call that is about to stop existing.
++ func TestAskCtrlCDismissesAndInterrupts(t *testing.T) {
++ 	m := newTestModel(t)
++ 	cancelled := false
++ 	m.cancel = func() { cancelled = true }
++ 	m.beforeModal = phaseRunning
++ 	m.phase = phaseRunning
++ 	reply := question(m, oneQuestion())
++ 	m.Update(key("ctrl+c"))
++ 	got := answered(t, reply)
++ 	if !got.Dismissed {
++ 		t.Fatal("ctrl-c is not an answer")
++ 	}
++ 	if !cancelled {
++ 		t.Error("the turn the question belonged to should have been interrupted")
++ 	}
++ }
++ // With nothing running there is no turn to cancel, and ctrl-c is only the
++ // dismissal. Cancelling here would tear down the next turn's context.
++ func TestAskCtrlCWhenIdleOnlyDismisses(t *testing.T) {
++ 	m := newTestModel(t)
++ 	cancelled := false
++ 	m.cancel = func() { cancelled = true }
++ 	reply := question(m, oneQuestion())
++ 	m.Update(key("ctrl+c"))
++ 	if got := answered(t, reply); !got.Dismissed {
++ 		t.Fatal("ctrl-c should dismiss")
++ 	}
++ 	if cancelled {
++ 		t.Error("nothing was running, so nothing should have been cancelled")
++ 	}
++ }
++ // Going back to a question puts the cursor on the answer you gave, because
++ // that is the thing you came back to change.
++ func TestAskGoingBackStartsOnTheAnswerGiven(t *testing.T) {
++ 	m := newTestModel(t)
++ 	question(m, ask.Request{Questions: []ask.Question{
++ 		{Header: "Storage", Question: "Where?", Options: []ask.Option{{Label: "Postgres"}, {Label: "SQLite"}}},
++ 		{Header: "Tests", Question: "How far?", Options: []ask.Option{{Label: "unit"}, {Label: "end to end"}}},
++ 	}})
++ 	m.Update(key("2")) // SQLite, on to the second question
++ 	m.Update(key("left"))
++ 	if got := m.asking[0].idx; got != 1 {
++ 		t.Errorf("cursor = %d, want the row holding the answer already given", got)
++ 	}
++ }

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

@@ -7,6 +7,7 @@ import (
7	7
8	8	"codey/internal/agent"
9	9	"codey/internal/approval"
	10	+ "codey/internal/ask"
10	11	"codey/internal/llm"
11	12	"codey/internal/subagent"
12	13	)
@@ -57,6 +58,14 @@ type (
57	58	reply chan<- approval.Decision
58	59	}
59	60
	61	+ // askMsg is a question the agent stopped to ask. Same shape as an
	62	+ // approval and the same buffered reply, because it is the same bargain:
	63	+ // the agent waits on a channel and the UI stays alive.
	64	+ askMsg struct {
	65	+ req ask.Request
	66	+ reply chan<- ask.Response
	67	+ }
	68	+
60	69	// turnDone reports the end of one prompt, with whatever the run returned.
61	70	turnDone struct {
62	71	err error
@@ -124,3 +133,25 @@ func (b *bridge) Prompt(ctx context.Context, req approval.Request) (approval.Dec
124	133	return approval.Deny, ctx.Err()
125	134	}
126	135	}
	136	+
	137	+ // Ask implements ask.Prompt: it puts a question on screen and waits for an
	138	+ // answer, honouring the context so an interrupted turn does not leave the
	139	+ // agent parked on a channel nobody will read.
	140	+ //
	141	+ // A cancelled question is not a dismissed one. Dismissal is a thing the user
	142	+ // did and the model is told about it; cancellation is the turn going away,
	143	+ // and the error says so.
	144	+ func (b *bridge) Ask(ctx context.Context, req ask.Request) (ask.Response, error) {
	145	+ if err := ctx.Err(); err != nil {
	146	+ return ask.Response{}, err
	147	+ }
	148	+ reply := make(chan ask.Response, 1)
	149	+ b.p.Send(askMsg{req: req, reply: reply})
	150	+
	151	+ select {
	152	+ case r := <-reply:
	153	+ return r, nil
	154	+ case <-ctx.Done():
	155	+ return ask.Response{}, ctx.Err()
	156	+ }
	157	+ }

+69−0internal/tui/bridge_test.goView File

@@ -11,6 +11,7 @@ import (
11	11
12	12	"codey/internal/agent"
13	13	"codey/internal/approval"
	14	+ "codey/internal/ask"
14	15	)
15	16
16	17	// recorder stands in for tea.Program: it captures what the bridge sends
@@ -177,3 +178,71 @@ var (
177	178	_ = func(b *bridge) { var _ func(agent.Event) = b.Observe }
178	179	_ = func(b *bridge) { var _ approval.Prompt = b.Prompt }
179	180	)
	181	+
	182	+ // A question blocks the agent the same way an approval does, and comes back
	183	+ // with exactly what the user picked.
	184	+ func TestAskBlocksUntilAnswered(t *testing.T) {
	185	+ r := &recorder{}
	186	+ r.onSend = func(m tea.Msg) {
	187	+ if am, ok := m.(askMsg); ok {
	188	+ go func() {
	189	+ time.Sleep(10 * time.Millisecond)
	190	+ am.reply <- ask.Response{Answers: []ask.Answer{{Chosen: []string{"Postgres"}}}}
	191	+ }()
	192	+ }
	193	+ }
	194	+ b := &bridge{p: r}
	195	+
	196	+ start := time.Now()
	197	+ got, err := b.Ask(context.Background(), ask.Request{Questions: []ask.Question{{Header: "Storage"}}})
	198	+ if err != nil {
	199	+ t.Fatalf("Ask: %v", err)
	200	+ }
	201	+ if len(got.Answers) != 1 \|\| got.Answers[0].Chosen[0] != "Postgres" {
	202	+ t.Errorf("response = %+v", got)
	203	+ }
	204	+ if time.Since(start) < 10*time.Millisecond {
	205	+ t.Error("Ask returned before the UI answered")
	206	+ }
	207	+ }
	208	+
	209	+ // The same deadlock the approval path has to avoid: an interrupted turn must
	210	+ // not leave the agent parked on a channel nobody will read.
	211	+ func TestAskUnblocksOnCancel(t *testing.T) {
	212	+ b := &bridge{p: &recorder{}} // never answers
	213	+ ctx, cancel := context.WithCancel(context.Background())
	214	+ go func() {
	215	+ time.Sleep(10 * time.Millisecond)
	216	+ cancel()
	217	+ }()
	218	+
	219	+ done := make(chan struct{})
	220	+ var err error
	221	+ go func() {
	222	+ _, err = b.Ask(ctx, ask.Request{})
	223	+ close(done)
	224	+ }()
	225	+
	226	+ select {
	227	+ case <-done:
	228	+ case <-time.After(2 * time.Second):
	229	+ t.Fatal("Ask did not return after its context was cancelled")
	230	+ }
	231	+ if err == nil {
	232	+ t.Error("a cancelled question is an error, not an empty answer")
	233	+ }
	234	+ }
	235	+
	236	+ func TestAskRefusesAnAlreadyCancelledContext(t *testing.T) {
	237	+ r := &recorder{}
	238	+ b := &bridge{p: r}
	239	+ ctx, cancel := context.WithCancel(context.Background())
	240	+ cancel()
	241	+
	242	+ if _, err := b.Ask(ctx, ask.Request{}); err == nil {
	243	+ t.Error("want an error for a context that was cancelled before the question")
	244	+ }
	245	+ if len(r.all()) != 0 {
	246	+ t.Error("a cancelled question still bothered the UI")
	247	+ }
	248	+ }

+84−22internal/tui/model.goView File

@@ -16,6 +16,7 @@ import (
16	16
17	17	"codey/internal/agent"
18	18	"codey/internal/approval"
	19	+ "codey/internal/ask"
19	20	"codey/internal/config"
20	21	"codey/internal/llm"
21	22	"codey/internal/skills"
@@ -25,8 +26,11 @@ import (
25	26	// Options wires the TUI to an already-built agent. The TUI owns no policy of
26	27	// its own: it renders what the agent reports and asks what the policy asks.
27	28	type Options struct {
28		- Agent *agent.Agent
29		- Policy *approval.Policy
	29	+ Agent *agent.Agent
	30	+ Policy *approval.Policy
	31	+ // Asker is what the ask_user tool reaches the user through. Nil means the
	32	+ // session has no such tool, and nothing here will try to draw a question.
	33	+ Asker *ask.Asker
30	34	Client *llm.Client
31	35	Root string
32	36	SessionDir string
@@ -77,6 +81,9 @@ const (
77	81	// phaseSettings is the settings panel, where the saved defaults are
78	82	// changed in place.
79	83	phaseSettings
	84	+ // phaseAsking is a question the agent stopped to ask. Like an approval it
	85	+ // is the agent waiting on a human rather than the other way round.
	86	+ phaseAsking
80	87	)
81	88
82	89	// inputMaxLines caps how far the prompt box grows before it scrolls. Past
@@ -173,10 +180,15 @@ type model struct {
173	180	// nothing and means a second request can never be dropped — and with
174	181	// subagents there can genuinely be several, from different agents.
175	182	pending []approvalMsg
176		- // beforeApproval is what the session was doing when the box went up. An
177		- // approval no longer implies a turn in flight: a subagent can ask while
178		- // you are idle, and answering has to put you back where you were.
179		- beforeApproval phase
	183	+ // asking is the queue of questions the agent has stopped to ask, the same
	184	+ // shape and for the same reasons as pending. Each carries its own
	185	+ // half-finished answers, so it is state rather than a bare message.
	186	+ asking []*askState
	187	+ // beforeModal is what the session was doing when the first box went up —
	188	+ // an approval or a question. Neither implies a turn in flight: a subagent
	189	+ // can ask while you are idle, and answering has to put you back where you
	190	+ // were.
	191	+ beforeModal phase
180	192
181	193	// ctx plumbing for the running turn.
182	194	parent context.Context
@@ -289,6 +301,12 @@ func Run(ctx context.Context, opts Options) error {
289	301	if opts.Policy != nil {
290	302	opts.Policy.Prompt = m.bridge.Prompt
291	303	}
	304	+ if opts.Asker != nil {
	305	+ // Until this line the tool would have reached whatever the line
	306	+ // front end installed, which is reading from a stdin the alt screen
	307	+ // has just taken over.
	308	+ opts.Asker.Use(m.bridge.Ask)
	309	+ }
292	310	if opts.Agents != nil {
293	311	opts.Agents.Subscribe(m.bridge.Subagent, m.bridge.AgentsChanged)
294	312	}
@@ -497,13 +515,27 @@ func (m *model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
497	515	return m, m.finishCompact(msg)
498	516
499	517	case approvalMsg:
500		- if m.phase != phaseApproving {
501		- m.beforeApproval = m.phase
	518	+ if !m.inModal() {
	519	+ m.beforeModal = m.phase
502	520	}
503	521	m.pending = append(m.pending, msg)
	522	+ // An approval outranks a question already on screen: the question can
	523	+ // wait, and a tool call cannot start until someone says so.
504	524	m.phase = phaseApproving
505	525	return m, m.sync()
506	526
	527	+ case askMsg:
	528	+ if !m.inModal() {
	529	+ m.beforeModal = m.phase
	530	+ }
	531	+ m.asking = append(m.asking, newAskState(msg.req, msg.reply))
	532	+ // An approval already on screen keeps it, the way it does when a
	533	+ // second approval arrives: the question is behind it, not lost.
	534	+ if m.phase != phaseApproving {
	535	+ m.phase = phaseAsking
	536	+ }
	537	+ return m, m.sync()
	538	+
507	539	case evSub:
508	540	return m, m.onSubEvent(msg.ev)
509	541
@@ -635,9 +667,24 @@ func (m *model) finishTurn(msg turnDone) tea.Cmd {
635	667	kept = append(kept, p)
636	668	}
637	669	m.pending = kept
638		- if len(m.pending) > 0 {
639		- m.phase = phaseApproving
640		- m.beforeApproval = phaseIdle
	670	+
	671	+ // A question outlives its turn no better than an approval does: the tool
	672	+ // call that asked it is gone, and nobody is left to read the answer. The
	673	+ // half-typed reply goes with it, and a subagent's question stays, for the
	674	+ // same reasons.
	675	+ var asking []*askState
	676	+ for _, s := range m.asking {
	677	+ if s.req.Agent == "" {
	678	+ s.reply <- ask.Response{Dismissed: true}
	679	+ continue
	680	+ }
	681	+ asking = append(asking, s)
	682	+ }
	683	+ m.asking = asking
	684	+
	685	+ if len(m.pending) > 0 \|\| len(m.asking) > 0 {
	686	+ m.beforeModal = phaseIdle
	687	+ m.phase = m.afterModal()
641	688	}
642	689
643	690	var full *agent.ContextFullError
@@ -663,6 +710,9 @@ func (m *model) onKey(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
663	710	if m.phase == phaseApproving {
664	711	return m.onApprovalKey(msg)
665	712	}
	713	+ if m.phase == phaseAsking {
	714	+ return m.onAskKey(msg)
	715	+ }
666	716	if m.phase == phaseEffort {
667	717	return m.onEffortKey(msg)
668	718	}
@@ -979,7 +1029,7 @@ func (m *model) choices(req approval.Request) []choice {
979	1029
980	1030	func (m *model) onApprovalKey(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
981	1031	if len(m.pending) == 0 {
982		- m.phase = m.beforeApproval
	1032	+ m.phase = m.afterModal()
983	1033	return m, nil
984	1034	}
985	1035	req := m.pending[0]
@@ -991,7 +1041,7 @@ func (m *model) onApprovalKey(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
991	1041	if key == "ctrl+c" {
992	1042	req.reply <- approval.Deny
993	1043	m.pending = m.pending[1:]
994		- m.phase = m.phaseAfterApproval()
	1044	+ m.phase = m.afterModal()
995	1045	if m.phase == phaseRunning {
996	1046	return m, tea.Batch(m.interrupt(), m.sync())
997	1047	}
@@ -1015,17 +1065,25 @@ func (m *model) onApprovalKey(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
1015	1065	return m, nil
1016	1066	}
1017	1067
1018		- // phaseAfterApproval is where the session goes once the queue empties: back to
1019		- // whatever it was doing, or straight on to the next request if one is waiting.
1020		- // An approval no longer implies a turn — a subagent can ask while you are idle
1021		- // — so answering one puts the session back where it found it.
1022		- func (m *model) phaseAfterApproval() phase {
1023		- if len(m.pending) > 0 {
	1068	+ // afterModal is where the session goes once a box is answered: on to the next
	1069	+ // thing waiting — another approval, or a question that had to stand aside for
	1070	+ // one — and otherwise back to whatever it was doing. Neither kind of box
	1071	+ // implies a turn, since a subagent can raise one while you are idle, so
	1072	+ // answering puts the session back where it found it.
	1073	+ func (m *model) afterModal() phase {
	1074	+ switch {
	1075	+ case len(m.pending) > 0:
1024	1076	return phaseApproving
	1077	+ case len(m.asking) > 0:
	1078	+ return phaseAsking
1025	1079	}
1026		- return m.beforeApproval
	1080	+ return m.beforeModal
1027	1081	}
1028	1082
	1083	+ // inModal says a box is on screen, which is how the session knows whether
	1084	+ // m.beforeModal already holds something worth going back to.
	1085	+ func (m *model) inModal() bool { return m.phase == phaseApproving \|\| m.phase == phaseAsking }
	1086	+
1029	1087	// answerApproval sends a decision and moves on. It is shared by the keys and
1030	1088	// by a click on the choice, which must not be able to decide differently.
1031	1089	func (m *model) answerApproval(c choice) tea.Cmd {
@@ -1035,7 +1093,7 @@ func (m *model) answerApproval(c choice) tea.Cmd {
1035	1093	req := m.pending[0]
1036	1094	req.reply <- c.dec
1037	1095	m.pending = m.pending[1:]
1038		- m.phase = m.phaseAfterApproval()
	1096	+ m.phase = m.afterModal()
1039	1097	// The decision belongs to the call it gated, not to whatever the
1040	1098	// transcript happens to end with once the result lands.
1041	1099	m.tr.annotateTool(req.req.Tool, c.note)
@@ -1149,6 +1207,8 @@ func (m *model) activity() string {
1149	1207	left = m.spin.View() + " " + styCoral.Render(verb+"…") + styDim.Render(" ("+detail+" · esc to interrupt)")
1150	1208	case phaseApproving:
1151	1209	left = styWarn.Render("● waiting for you")
	1210	+ case phaseAsking:
	1211	+ left = styWarn.Render("● the agent has a question")
1152	1212	}
1153	1213
1154	1214	// What was copied is reported here rather than in the transcript: five
@@ -1299,7 +1359,9 @@ func (m *model) contextWindow() int {
1299	1359	// modeLine reports what the approval policy will do next, because a mode that
1300	1360	// silently lets the agent write to disk has to be visible at all times.
1301	1361	func (m *model) modeLine() string {
1302		- if m.phase == phaseApproving {
	1362	+ // While a box is up, shift+tab belongs to it and the line would be
	1363	+ // advertising a key that does something else.
	1364	+ if m.inModal() {
1303	1365	return ""
1304	1366	}
1305	1367	agents := ""

+29−0internal/tui/mouse.goView File

@@ -34,6 +34,7 @@ const (
34	34	secStatus
35	35	secMode
36	36	secApproval
	37	+ secAsk
37	38	secEffort
38	39	secModel
39	40	secSettings
@@ -55,6 +56,8 @@ func (m *model) layout() []section {
55	56	switch {
56	57	case m.phase == phaseApproving && len(m.pending) > 0:
57	58	secs = append(secs, section{secApproval, m.approvalView()})
	59	+ case m.phase == phaseAsking && len(m.asking) > 0:
	60	+ secs = append(secs, section{secAsk, m.askView()})
58	61	case m.phase == phaseEffort:
59	62	secs = append(secs, section{secEffort, m.effortView()})
60	63	case m.phase == phaseModel:
@@ -282,6 +285,14 @@ func (m *model) onChromeWheel(kind sectionKind, msg tea.MouseMsg) tea.Cmd {
282	285	case secEffort:
283	286	m.effortIdx = clampIdx(m.effortIdx+step(up), len(llm.EffortLevels))
284	287	return nil
	288	+ case secAsk:
	289	+ // The wheel moves the cursor and nothing else, for the reason the
	290	+ // settings panel gives: a roll that answered the question on its own
	291	+ // would be a decision nobody made.
	292	+ if len(m.asking) > 0 && !m.asking[0].typing {
	293	+ m.asking[0].move(step(up))
	294	+ }
	295	+ return nil
285	296	case secSettings:
286	297	// The wheel moves between rows rather than changing a value: a roll
287	298	// that silently turned approvals off would be the worst possible
@@ -335,6 +346,24 @@ func (m *model) onChromeClick(kind sectionKind, row, x int) (tea.Model, tea.Cmd)
335	346	}
336	347	return m, nil
337	348
	349	+ case secAsk:
	350	+ if len(m.asking) == 0 {
	351	+ return m, nil
	352	+ }
	353	+ // The hit map is what the last frame actually drew, so a click on the
	354	+ // description under a label lands on that option rather than between
	355	+ // two of them. Row 0 of the section is the box's top border, which is
	356	+ // what the map does not count.
	357	+ s := m.asking[0]
	358	+ if s.typing {
	359	+ return m, nil
	360	+ }
	361	+ if i, ok := s.hit[row-1]; ok {
	362	+ s.idx = i
	363	+ return m, m.activateAsk(s)
	364	+ }
	365	+ return m, nil
	366	+
338	367	case secApproval:
339	368	if len(m.pending) == 0 {
340	369	return m, nil

+27−0internal/tui/transcript.goView File

@@ -463,6 +463,9 @@ func summarizeInput(raw json.RawMessage) string {
463	463	if len(raw) == 0 \|\| json.Unmarshal(raw, &m) != nil {
464	464	return string(raw)
465	465	}
	466	+ if s := summarizeQuestions(m); s != "" {
	467	+ return s
	468	+ }
466	469	keys := make([]string, 0, len(m))
467	470	for k := range m {
468	471	keys = append(keys, k)
@@ -476,3 +479,27 @@ func summarizeInput(raw json.RawMessage) string {
476	479	}
477	480	return strings.Join(parts, ", ")
478	481	}
	482	+
	483	+ // summarizeQuestions is ask_user's arguments, which are a list of maps and
	484	+ // render as unreadable rubbish through the k=v path. What the line wants is
	485	+ // the question. It keys off the shape rather than the tool name because that
	486	+ // is all summarizeInput is given, and nothing else here sends a "questions"
	487	+ // list of objects with a "question" in them.
	488	+ func summarizeQuestions(m map[string]any) string {
	489	+ qs, ok := m["questions"].([]any)
	490	+ if !ok \|\| len(qs) == 0 {
	491	+ return ""
	492	+ }
	493	+ first, ok := qs[0].(map[string]any)
	494	+ if !ok {
	495	+ return ""
	496	+ }
	497	+ text, ok := first["question"].(string)
	498	+ if !ok \|\| text == "" {
	499	+ return ""
	500	+ }
	501	+ if n := len(qs); n > 1 {
	502	+ return fmt.Sprintf("%s (+%d more)", truncate(text, 60), n-1)
	503	+ }
	504	+ return truncate(text, 70)
	505	+ }

+25−0internal/tui/transcript_test.goView File

@@ -338,3 +338,28 @@ func TestBlankLinesCarryNoGutter(t *testing.T) {
338	338	}
339	339	}
340	340	}
	341	+
	342	+ // ask_user's arguments are a list of objects, which through the k=v path
	343	+ // renders as map[...] noise. The transcript line should be the question.
	344	+ func TestSummarizeInputShowsTheQuestion(t *testing.T) {
	345	+ raw := json.RawMessage(`{"questions":[
	346	+ {"header":"Storage","question":"How should sessions be stored?","options":[{"label":"Postgres"}]},
	347	+ {"header":"Tests","question":"How far?","options":[{"label":"unit"}]}]}`)
	348	+
	349	+ got := summarizeInput(raw)
	350	+ if !strings.Contains(got, "How should sessions be stored?") {
	351	+ t.Errorf("summary = %q, want the first question", got)
	352	+ }
	353	+ if !strings.Contains(got, "+1 more") {
	354	+ t.Errorf("summary = %q, should say the other questions are there", got)
	355	+ }
	356	+ }
	357	+
	358	+ // Nothing else sends a "questions" list, but the shape test must not swallow
	359	+ // a tool call that merely has a field of that name.
	360	+ func TestSummarizeInputLeavesOtherToolsAlone(t *testing.T) {
	361	+ got := summarizeInput(json.RawMessage(`{"questions":"how many"}`))
	362	+ if got != "questions=how many" {
	363	+ t.Errorf("summary = %q, want the ordinary k=v rendering", got)
	364	+ }
	365	+ }

+118−0internal/ui/ask.goaddedView File

++ package ui
++ import (
++ 	"bufio"
++ 	"context"
++ 	"fmt"
++ 	"io"
++ 	"strconv"
++ 	"strings"
++ 	"codey/internal/ask"
++ )
++ // Asker puts the agent's questions to a terminal, one line at a time. It is
++ // to the question box what Approver is to the approval box: the same decision
++ // without a full-screen program to draw it in.
++ //
++ // Stdin closing is not an answer. A piped or scripted run reaches EOF at the
++ // first question, and the tool tells the model to decide for itself — which
++ // is what should happen when nobody is there.
++ type Asker struct {
++ 	In  *bufio.Scanner
++ 	Out io.Writer
++ }
++ // Prompt implements ask.Prompt.
++ func (a *Asker) Prompt(ctx context.Context, req ask.Request) (ask.Response, error) {
++ 	if err := ctx.Err(); err != nil {
++ 		return ask.Response{}, err
++ 	}
++ 	resp := ask.Response{}
++ 	for _, q := range req.Questions {
++ 		if err := ctx.Err(); err != nil {
++ 			return ask.Response{}, err
++ 		}
++ 		answer, ok := a.one(q)
++ 		if !ok {
++ 			// One question skipped is the whole request abandoned: a partial
++ 			// set of answers would be reported as if it were complete.
++ 			return ask.Response{Dismissed: true}, nil
++ 		}
++ 		resp.Answers = append(resp.Answers, answer)
++ 	}
++ 	return resp, nil
++ }
++ func (a *Asker) one(q ask.Question) (ask.Answer, bool) {
++ 	answer := ask.Answer{Header: strings.TrimSpace(q.Header), Question: strings.TrimSpace(q.Question)}
++ 	fmt.Fprintf(a.Out, "\n%s%s%s %s\n", color.bold, answer.Header, color.reset, answer.Question)
++ 	for i, o := range q.Options {
++ 		fmt.Fprintf(a.Out, "  %s%d.%s %s\n", color.cyan, i+1, color.reset, o.Label)
++ 		if o.Description != "" {
++ 			fmt.Fprintf(a.Out, "     %s%s%s\n", color.dim, o.Description, color.reset)
++ 		}
++ 	}
++ 	how := fmt.Sprintf("answer 1-%d", len(q.Options))
++ 	if q.MultiSelect {
++ 		how = fmt.Sprintf("answer 1-%d, several separated by commas", len(q.Options))
++ 	}
++ 	for {
++ 		fmt.Fprintf(a.Out, "%s%s, type something else, or press enter to skip%s\n> ", color.dim, how, color.reset)
++ 		if !a.In.Scan() {
++ 			fmt.Fprintln(a.Out)
++ 			return answer, false
++ 		}
++ 		text := strings.TrimSpace(a.In.Text())
++ 		if text == "" {
++ 			return answer, false
++ 		}
++ 		picked, numeric := parseChoices(text, len(q.Options))
++ 		switch {
++ 		case !numeric:
++ 			// Anything that is not a list of numbers is the user answering in
++ 			// their own words, which is always allowed.
++ 			answer.Other = text
++ 			return answer, true
++ 		case len(picked) == 0:
++ 			fmt.Fprintf(a.Out, "%sthere is no option %s%s\n", color.red, text, color.reset)
++ 			continue
++ 		case len(picked) > 1 && !q.MultiSelect:
++ 			fmt.Fprintf(a.Out, "%sthis question takes one answer%s\n", color.red, color.reset)
++ 			continue
++ 		}
++ 		for _, i := range picked {
++ 			answer.Chosen = append(answer.Chosen, q.Options[i].Label)
++ 		}
++ 		return answer, true
++ 	}
++ }
++ // parseChoices reads "2" or "1,3" as option indices. numeric is false as soon
++ // as any part is not a number, which is how a typed answer is told from a
++ // chosen one; picked is empty when every part was a number but one was out of
++ // range, which is a mistake worth saying out loud rather than filing as prose.
++ func parseChoices(text string, n int) (picked []int, numeric bool) {
++ 	parts := strings.FieldsFunc(text, func(r rune) bool { return r == ',' || r == ' ' })
++ 	if len(parts) == 0 {
++ 		return nil, false
++ 	}
++ 	seen := map[int]bool{}
++ 	for _, p := range parts {
++ 		v, err := strconv.Atoi(strings.TrimSpace(p))
++ 		if err != nil {
++ 			return nil, false
++ 		}
++ 		if v < 1 || v > n {
++ 			return nil, true
++ 		}
++ 		if !seen[v-1] {
++ 			seen[v-1] = true
++ 			picked = append(picked, v-1)
++ 		}
++ 	}
++ 	return picked, true
++ }

+143−0internal/ui/ask_test.goaddedView File

++ package ui
++ import (
++ 	"bufio"
++ 	"bytes"
++ 	"context"
++ 	"strings"
++ 	"testing"
++ 	"codey/internal/ask"
++ )
++ func askOn(t *testing.T, input string, req ask.Request) (ask.Response, string) {
++ 	t.Helper()
++ 	var out bytes.Buffer
++ 	a := &Asker{In: bufio.NewScanner(strings.NewReader(input)), Out: &out}
++ 	resp, err := a.Prompt(context.Background(), req)
++ 	if err != nil {
++ 		t.Fatalf("Prompt: %v", err)
++ 	}
++ 	return resp, out.String()
++ }
++ func storage() ask.Request {
++ 	return ask.Request{Questions: []ask.Question{{
++ 		Header:   "Storage",
++ 		Question: "How should sessions be stored?",
++ 		Options: []ask.Option{
++ 			{Label: "Postgres", Description: "already running"},
++ 			{Label: "SQLite"},
++ 		},
++ 	}}}
++ }
++ func TestLineAskerTakesANumberedAnswer(t *testing.T) {
++ 	got, printed := askOn(t, "2\n", storage())
++ 	if got.Dismissed || len(got.Answers) != 1 || got.Answers[0].Chosen[0] != "SQLite" {
++ 		t.Fatalf("response = %+v", got)
++ 	}
++ 	for _, want := range []string{"Storage", "How should sessions be stored?", "1.", "Postgres", "already running"} {
++ 		if !strings.Contains(printed, want) {
++ 			t.Errorf("the prompt never showed %q:\n%s", want, printed)
++ 		}
++ 	}
++ }
++ // Anything that is not a number is the user answering in their own words,
++ // which every question allows.
++ func TestLineAskerTakesWordsAsTheAnswer(t *testing.T) {
++ 	got, _ := askOn(t, "neither, keep them in memory\n", storage())
++ 	if got.Answers[0].Other != "neither, keep them in memory" {
++ 		t.Fatalf("Other = %q", got.Answers[0].Other)
++ 	}
++ 	if len(got.Answers[0].Chosen) != 0 {
++ 		t.Error("typed words are not a chosen option")
++ 	}
++ }
++ func TestLineAskerRefusesANumberThatIsNotAnOption(t *testing.T) {
++ 	got, printed := askOn(t, "7\n1\n", storage())
++ 	if !strings.Contains(printed, "no option 7") {
++ 		t.Errorf("expected the mistake to be named:\n%s", printed)
++ 	}
++ 	if got.Answers[0].Chosen[0] != "Postgres" {
++ 		t.Fatalf("response = %+v, want the answer given second", got)
++ 	}
++ }
++ func TestLineAskerTakesSeveralWhenTheQuestionAllowsIt(t *testing.T) {
++ 	req := ask.Request{Questions: []ask.Question{{
++ 		Header: "Scope", Question: "What should it cover?", MultiSelect: true,
++ 		Options: []ask.Option{{Label: "the CLI"}, {Label: "the TUI"}, {Label: "the docs"}},
++ 	}}}
++ 	got, _ := askOn(t, "1,3\n", req)
++ 	if want := "the CLI,the docs"; strings.Join(got.Answers[0].Chosen, ",") != want {
++ 		t.Fatalf("chosen = %v, want %s", got.Answers[0].Chosen, want)
++ 	}
++ }
++ // One answer means one. Two numbers is a misunderstanding worth correcting
++ // rather than a free-text answer to file.
++ func TestLineAskerRefusesSeveralAnswersToOneQuestion(t *testing.T) {
++ 	got, printed := askOn(t, "1,2\n2\n", storage())
++ 	if !strings.Contains(printed, "takes one answer") {
++ 		t.Errorf("expected a correction:\n%s", printed)
++ 	}
++ 	if got.Answers[0].Chosen[0] != "SQLite" {
++ 		t.Fatalf("response = %+v", got)
++ 	}
++ }
++ // An empty line is a skip, and a skipped question abandons the request: half
++ // the answers reported as if they were all of them is worse than none.
++ func TestLineAskerSkipOnEmptyLine(t *testing.T) {
++ 	req := storage()
++ 	req.Questions = append(req.Questions, ask.Question{
++ 		Header: "Tests", Question: "How far?", Options: []ask.Option{{Label: "unit"}, {Label: "e2e"}},
++ 	})
++ 	got, _ := askOn(t, "1\n\n", req)
++ 	if !got.Dismissed {
++ 		t.Fatalf("response = %+v, want a dismissal", got)
++ 	}
++ 	if len(got.Answers) != 0 {
++ 		t.Error("a dismissed request carries no answers")
++ 	}
++ }
++ // Nobody is there: a piped run reaches EOF, and the tool turns that into an
++ // instruction to decide alone rather than waiting forever.
++ func TestLineAskerClosedStdinIsNotAnAnswer(t *testing.T) {
++ 	got, _ := askOn(t, "", storage())
++ 	if !got.Dismissed {
++ 		t.Fatalf("response = %+v, want a dismissal", got)
++ 	}
++ }
++ func TestLineAskerAsksEveryQuestion(t *testing.T) {
++ 	req := storage()
++ 	req.Questions = append(req.Questions, ask.Question{
++ 		Header: "Tests", Question: "How far should the tests go?", Options: []ask.Option{{Label: "unit"}, {Label: "e2e"}},
++ 	})
++ 	got, printed := askOn(t, "1\n2\n", req)
++ 	if len(got.Answers) != 2 {
++ 		t.Fatalf("got %d answers, want one per question", len(got.Answers))
++ 	}
++ 	if got.Answers[1].Chosen[0] != "e2e" {
++ 		t.Errorf("second answer = %v", got.Answers[1].Chosen)
++ 	}
++ 	if !strings.Contains(printed, "How far should the tests go?") {
++ 		t.Error("the second question was never put")
++ 	}
++ }