cmd: TUI UX improvements (#14198)

cmd/tui/confirm.go

@@ -0,0 +1,109 @@
+package tui
+
+import (
+	"fmt"
+
+	tea "github.com/charmbracelet/bubbletea"
+	"github.com/charmbracelet/lipgloss"
+)
+
+var (
+	confirmActiveStyle = lipgloss.NewStyle().
+				Bold(true).
+				Background(lipgloss.AdaptiveColor{Light: "254", Dark: "236"})
+
+	confirmInactiveStyle = lipgloss.NewStyle().
+				Foreground(lipgloss.AdaptiveColor{Light: "242", Dark: "246"})
+)
+
+type confirmModel struct {
+	prompt    string
+	yes       bool
+	confirmed bool
+	cancelled bool
+	width     int
+}
+
+func (m confirmModel) Init() tea.Cmd {
+	return nil
+}
+
+func (m confirmModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
+	switch msg := msg.(type) {
+	case tea.WindowSizeMsg:
+		wasSet := m.width > 0
+		m.width = msg.Width
+		if wasSet {
+			return m, tea.EnterAltScreen
+		}
+		return m, nil
+
+	case tea.KeyMsg:
+		switch msg.String() {
+		case "ctrl+c", "esc", "n":
+			m.cancelled = true
+			return m, tea.Quit
+		case "y":
+			m.yes = true
+			m.confirmed = true
+			return m, tea.Quit
+		case "enter":
+			m.confirmed = true
+			return m, tea.Quit
+		case "left", "h":
+			m.yes = true
+		case "right", "l":
+			m.yes = false
+		case "tab":
+			m.yes = !m.yes
+		}
+	}
+
+	return m, nil
+}
+
+func (m confirmModel) View() string {
+	if m.confirmed || m.cancelled {
+		return ""
+	}
+
+	var yesBtn, noBtn string
+	if m.yes {
+		yesBtn = confirmActiveStyle.Render(" Yes ")
+		noBtn = confirmInactiveStyle.Render(" No ")
+	} else {
+		yesBtn = confirmInactiveStyle.Render(" Yes ")
+		noBtn = confirmActiveStyle.Render(" No ")
+	}
+
+	s := selectorTitleStyle.Render(m.prompt) + "\n\n"
+	s += "  " + yesBtn + "  " + noBtn + "\n\n"
+	s += selectorHelpStyle.Render("←/→ navigate • enter confirm • esc cancel")
+
+	if m.width > 0 {
+		return lipgloss.NewStyle().MaxWidth(m.width).Render(s)
+	}
+	return s
+}
+
+// RunConfirm shows a bubbletea yes/no confirmation prompt.
+// Returns true if the user confirmed, false if cancelled.
+func RunConfirm(prompt string) (bool, error) {
+	m := confirmModel{
+		prompt: prompt,
+		yes:    true, // default to yes
+	}
+
+	p := tea.NewProgram(m)
+	finalModel, err := p.Run()
+	if err != nil {
+		return false, fmt.Errorf("error running confirm: %w", err)
+	}
+
+	fm := finalModel.(confirmModel)
+	if fm.cancelled {
+		return false, ErrCancelled
+	}
+
+	return fm.yes, nil
+}

cmd/tui/confirm_test.go

@@ -0,0 +1,208 @@
+package tui
+
+import (
+	"strings"
+	"testing"
+
+	tea "github.com/charmbracelet/bubbletea"
+)
+
+func TestConfirmModel_DefaultsToYes(t *testing.T) {
+	m := confirmModel{prompt: "Download test?", yes: true}
+	if !m.yes {
+		t.Error("should default to yes")
+	}
+}
+
+func TestConfirmModel_View_ContainsPrompt(t *testing.T) {
+	m := confirmModel{prompt: "Download qwen3:8b?", yes: true}
+	got := m.View()
+	if !strings.Contains(got, "Download qwen3:8b?") {
+		t.Error("should contain the prompt text")
+	}
+}
+
+func TestConfirmModel_View_ContainsButtons(t *testing.T) {
+	m := confirmModel{prompt: "Download?", yes: true}
+	got := m.View()
+	if !strings.Contains(got, "Yes") {
+		t.Error("should contain Yes button")
+	}
+	if !strings.Contains(got, "No") {
+		t.Error("should contain No button")
+	}
+}
+
+func TestConfirmModel_View_ContainsHelp(t *testing.T) {
+	m := confirmModel{prompt: "Download?", yes: true}
+	got := m.View()
+	if !strings.Contains(got, "enter confirm") {
+		t.Error("should contain help text")
+	}
+}
+
+func TestConfirmModel_View_ClearsAfterConfirm(t *testing.T) {
+	m := confirmModel{prompt: "Download?", confirmed: true}
+	if m.View() != "" {
+		t.Error("View should return empty string after confirmation")
+	}
+}
+
+func TestConfirmModel_View_ClearsAfterCancel(t *testing.T) {
+	m := confirmModel{prompt: "Download?", cancelled: true}
+	if m.View() != "" {
+		t.Error("View should return empty string after cancellation")
+	}
+}
+
+func TestConfirmModel_EnterConfirmsYes(t *testing.T) {
+	m := confirmModel{prompt: "Download?", yes: true}
+	updated, cmd := m.Update(tea.KeyMsg{Type: tea.KeyEnter})
+	fm := updated.(confirmModel)
+	if !fm.confirmed {
+		t.Error("enter should set confirmed=true")
+	}
+	if !fm.yes {
+		t.Error("enter with yes selected should keep yes=true")
+	}
+	if cmd == nil {
+		t.Error("enter should return tea.Quit")
+	}
+}
+
+func TestConfirmModel_EnterConfirmsNo(t *testing.T) {
+	m := confirmModel{prompt: "Download?", yes: false}
+	updated, cmd := m.Update(tea.KeyMsg{Type: tea.KeyEnter})
+	fm := updated.(confirmModel)
+	if !fm.confirmed {
+		t.Error("enter should set confirmed=true")
+	}
+	if fm.yes {
+		t.Error("enter with no selected should keep yes=false")
+	}
+	if cmd == nil {
+		t.Error("enter should return tea.Quit")
+	}
+}
+
+func TestConfirmModel_EscCancels(t *testing.T) {
+	m := confirmModel{prompt: "Download?", yes: true}
+	updated, cmd := m.Update(tea.KeyMsg{Type: tea.KeyEsc})
+	fm := updated.(confirmModel)
+	if !fm.cancelled {
+		t.Error("esc should set cancelled=true")
+	}
+	if cmd == nil {
+		t.Error("esc should return tea.Quit")
+	}
+}
+
+func TestConfirmModel_CtrlCCancels(t *testing.T) {
+	m := confirmModel{prompt: "Download?", yes: true}
+	updated, cmd := m.Update(tea.KeyMsg{Type: tea.KeyCtrlC})
+	fm := updated.(confirmModel)
+	if !fm.cancelled {
+		t.Error("ctrl+c should set cancelled=true")
+	}
+	if cmd == nil {
+		t.Error("ctrl+c should return tea.Quit")
+	}
+}
+
+func TestConfirmModel_NCancels(t *testing.T) {
+	m := confirmModel{prompt: "Download?", yes: true}
+	updated, cmd := m.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{'n'}})
+	fm := updated.(confirmModel)
+	if !fm.cancelled {
+		t.Error("'n' should set cancelled=true")
+	}
+	if cmd == nil {
+		t.Error("'n' should return tea.Quit")
+	}
+}
+
+func TestConfirmModel_YConfirmsYes(t *testing.T) {
+	m := confirmModel{prompt: "Download?", yes: false}
+	updated, cmd := m.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{'y'}})
+	fm := updated.(confirmModel)
+	if !fm.confirmed {
+		t.Error("'y' should set confirmed=true")
+	}
+	if !fm.yes {
+		t.Error("'y' should set yes=true")
+	}
+	if cmd == nil {
+		t.Error("'y' should return tea.Quit")
+	}
+}
+
+func TestConfirmModel_ArrowKeysNavigate(t *testing.T) {
+	m := confirmModel{prompt: "Download?", yes: true}
+
+	// Right moves to No
+	updated, _ := m.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{'l'}})
+	fm := updated.(confirmModel)
+	if fm.yes {
+		t.Error("right/l should move to No")
+	}
+	if fm.confirmed || fm.cancelled {
+		t.Error("navigation should not confirm or cancel")
+	}
+
+	// Left moves back to Yes
+	updated, _ = fm.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{'h'}})
+	fm = updated.(confirmModel)
+	if !fm.yes {
+		t.Error("left/h should move to Yes")
+	}
+}
+
+func TestConfirmModel_TabToggles(t *testing.T) {
+	m := confirmModel{prompt: "Download?", yes: true}
+
+	updated, _ := m.Update(tea.KeyMsg{Type: tea.KeyTab})
+	fm := updated.(confirmModel)
+	if fm.yes {
+		t.Error("tab should toggle from Yes to No")
+	}
+
+	updated, _ = fm.Update(tea.KeyMsg{Type: tea.KeyTab})
+	fm = updated.(confirmModel)
+	if !fm.yes {
+		t.Error("tab should toggle from No to Yes")
+	}
+}
+
+func TestConfirmModel_WindowSizeUpdatesWidth(t *testing.T) {
+	m := confirmModel{prompt: "Download?"}
+	updated, _ := m.Update(tea.WindowSizeMsg{Width: 100, Height: 40})
+	fm := updated.(confirmModel)
+	if fm.width != 100 {
+		t.Errorf("expected width 100, got %d", fm.width)
+	}
+}
+
+func TestConfirmModel_ResizeEntersAltScreen(t *testing.T) {
+	m := confirmModel{prompt: "Download?", width: 80}
+	_, cmd := m.Update(tea.WindowSizeMsg{Width: 100, Height: 40})
+	if cmd == nil {
+		t.Error("resize (width already set) should return a command")
+	}
+}
+
+func TestConfirmModel_InitialWindowSizeNoAltScreen(t *testing.T) {
+	m := confirmModel{prompt: "Download?"}
+	_, cmd := m.Update(tea.WindowSizeMsg{Width: 80, Height: 40})
+	if cmd != nil {
+		t.Error("initial WindowSizeMsg should not return a command")
+	}
+}
+
+func TestConfirmModel_ViewMaxWidth(t *testing.T) {
+	m := confirmModel{prompt: "Download?", yes: true, width: 40}
+	got := m.View()
+	// Just ensure it doesn't panic and returns content
+	if got == "" {
+		t.Error("View with width set should still return content")
+	}
+}

cmd/tui/selector.go

@@ -18,35 +18,44 @@ var (
 
 	selectorSelectedItemStyle = lipgloss.NewStyle().
 					PaddingLeft(2).
-					Bold(true)
+					Bold(true).
+					Background(lipgloss.AdaptiveColor{Light: "254", Dark: "236"})
 
 	selectorDescStyle = lipgloss.NewStyle().
-				Foreground(lipgloss.Color("241"))
+				Foreground(lipgloss.AdaptiveColor{Light: "242", Dark: "246"})
+
+	selectorDescLineStyle = selectorDescStyle.
+				PaddingLeft(6)
 
 	selectorFilterStyle = lipgloss.NewStyle().
-				Foreground(lipgloss.Color("241")).
+				Foreground(lipgloss.AdaptiveColor{Light: "242", Dark: "246"}).
 				Italic(true)
 
 	selectorInputStyle = lipgloss.NewStyle().
-				Foreground(lipgloss.Color("252"))
+				Foreground(lipgloss.AdaptiveColor{Light: "235", Dark: "252"})
 
 	selectorCheckboxStyle = lipgloss.NewStyle().
-				Foreground(lipgloss.Color("241"))
+				Foreground(lipgloss.AdaptiveColor{Light: "242", Dark: "246"})
 
 	selectorCheckboxCheckedStyle = lipgloss.NewStyle().
 					Bold(true)
 
 	selectorDefaultTagStyle = lipgloss.NewStyle().
-				Foreground(lipgloss.Color("241")).
+				Foreground(lipgloss.AdaptiveColor{Light: "242", Dark: "246"}).
 				Italic(true)
 
 	selectorHelpStyle = lipgloss.NewStyle().
-				Foreground(lipgloss.Color("241"))
+				Foreground(lipgloss.AdaptiveColor{Light: "244", Dark: "244"})
 
 	selectorMoreStyle = lipgloss.NewStyle().
-				PaddingLeft(4).
-				Foreground(lipgloss.Color("241")).
+				PaddingLeft(6).
+				Foreground(lipgloss.AdaptiveColor{Light: "242", Dark: "246"}).
 				Italic(true)
+
+	sectionHeaderStyle = lipgloss.NewStyle().
+				PaddingLeft(2).
+				Bold(true).
+				Foreground(lipgloss.AdaptiveColor{Light: "240", Dark: "249"})
 )
 
 const maxSelectorItems = 10
@@ -54,10 +63,10 @@ const maxSelectorItems = 10
 // ErrCancelled is returned when the user cancels the selection.
 var ErrCancelled = errors.New("cancelled")
 
-// SelectItem represents an item that can be selected.
 type SelectItem struct {
 	Name        string
 	Description string
+	Recommended bool
 }
 
 // selectorModel is the bubbletea model for single selection.
@@ -69,6 +78,8 @@ type selectorModel struct {
 	scrollOffset int
 	selected     string
 	cancelled    bool
+	helpText     string
+	width        int
 }
 
 func (m selectorModel) filteredItems() []SelectItem {
@@ -89,83 +100,153 @@ func (m selectorModel) Init() tea.Cmd {
 	return nil
 }
 
+// otherStart returns the index of the first non-recommended item in the filtered list.
+// When filtering, all items scroll together so this returns 0.
+func (m selectorModel) otherStart() int {
+	if m.filter != "" {
+		return 0
+	}
+	filtered := m.filteredItems()
+	for i, item := range filtered {
+		if !item.Recommended {
+			return i
+		}
+	}
+	return len(filtered)
+}
+
+// updateNavigation handles navigation keys (up/down/pgup/pgdown/filter/backspace).
+// It does NOT handle Enter, Esc, or CtrlC. This is used by both the standalone
+// selector and the TUI modal (which intercepts Enter/Esc for its own logic).
+func (m *selectorModel) updateNavigation(msg tea.KeyMsg) {
+	filtered := m.filteredItems()
+	otherStart := m.otherStart()
+
+	switch msg.Type {
+	case tea.KeyUp:
+		if m.cursor > 0 {
+			m.cursor--
+			m.updateScroll(otherStart)
+		}
+
+	case tea.KeyDown:
+		if m.cursor < len(filtered)-1 {
+			m.cursor++
+			m.updateScroll(otherStart)
+		}
+
+	case tea.KeyPgUp:
+		m.cursor -= maxSelectorItems
+		if m.cursor < 0 {
+			m.cursor = 0
+		}
+		m.updateScroll(otherStart)
+
+	case tea.KeyPgDown:
+		m.cursor += maxSelectorItems
+		if m.cursor >= len(filtered) {
+			m.cursor = len(filtered) - 1
+		}
+		m.updateScroll(otherStart)
+
+	case tea.KeyBackspace:
+		if len(m.filter) > 0 {
+			m.filter = m.filter[:len(m.filter)-1]
+			m.cursor = 0
+			m.scrollOffset = 0
+		}
+
+	case tea.KeyRunes:
+		m.filter += string(msg.Runes)
+		m.cursor = 0
+		m.scrollOffset = 0
+	}
+}
+
+// updateScroll adjusts scrollOffset based on cursor position.
+// When not filtering, scrollOffset is relative to the "More" (non-recommended) section.
+// When filtering, it's relative to the full filtered list.
+func (m *selectorModel) updateScroll(otherStart int) {
+	if m.filter != "" {
+		if m.cursor < m.scrollOffset {
+			m.scrollOffset = m.cursor
+		}
+		if m.cursor >= m.scrollOffset+maxSelectorItems {
+			m.scrollOffset = m.cursor - maxSelectorItems + 1
+		}
+		return
+	}
+
+	// Cursor is in recommended section — reset "More" scroll to top
+	if m.cursor < otherStart {
+		m.scrollOffset = 0
+		return
+	}
+
+	// Cursor is in "More" section — scroll relative to others
+	posInOthers := m.cursor - otherStart
+	maxOthers := maxSelectorItems - otherStart
+	if maxOthers < 3 {
+		maxOthers = 3
+	}
+	if posInOthers < m.scrollOffset {
+		m.scrollOffset = posInOthers
+	}
+	if posInOthers >= m.scrollOffset+maxOthers {
+		m.scrollOffset = posInOthers - maxOthers + 1
+	}
+}
+
 func (m selectorModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 	switch msg := msg.(type) {
-	case tea.KeyMsg:
-		filtered := m.filteredItems()
+	case tea.WindowSizeMsg:
+		wasSet := m.width > 0
+		m.width = msg.Width
+		if wasSet {
+			return m, tea.EnterAltScreen
+		}
+		return m, nil
 
+	case tea.KeyMsg:
 		switch msg.Type {
 		case tea.KeyCtrlC, tea.KeyEsc:
 			m.cancelled = true
 			return m, tea.Quit
 
 		case tea.KeyEnter:
+			filtered := m.filteredItems()
 			if len(filtered) > 0 && m.cursor < len(filtered) {
 				m.selected = filtered[m.cursor].Name
 			}
 			return m, tea.Quit
 
-		case tea.KeyUp:
-			if m.cursor > 0 {
-				m.cursor--
-				if m.cursor < m.scrollOffset {
-					m.scrollOffset = m.cursor
-				}
-			}
-
-		case tea.KeyDown:
-			if m.cursor < len(filtered)-1 {
-				m.cursor++
-				if m.cursor >= m.scrollOffset+maxSelectorItems {
-					m.scrollOffset = m.cursor - maxSelectorItems + 1
-				}
-			}
-
-		case tea.KeyPgUp:
-			m.cursor -= maxSelectorItems
-			if m.cursor < 0 {
-				m.cursor = 0
-			}
-			m.scrollOffset -= maxSelectorItems
-			if m.scrollOffset < 0 {
-				m.scrollOffset = 0
-			}
-
-		case tea.KeyPgDown:
-			m.cursor += maxSelectorItems
-			if m.cursor >= len(filtered) {
-				m.cursor = len(filtered) - 1
-			}
-			if m.cursor >= m.scrollOffset+maxSelectorItems {
-				m.scrollOffset = m.cursor - maxSelectorItems + 1
-			}
-
-		case tea.KeyBackspace:
-			if len(m.filter) > 0 {
-				m.filter = m.filter[:len(m.filter)-1]
-				m.cursor = 0
-				m.scrollOffset = 0
-			}
-
-		case tea.KeyRunes:
-			m.filter += string(msg.Runes)
-			m.cursor = 0
-			m.scrollOffset = 0
+		default:
+			m.updateNavigation(msg)
 		}
 	}
 
 	return m, nil
 }
 
-func (m selectorModel) View() string {
-	// Clear screen when exiting
-	if m.cancelled || m.selected != "" {
-		return ""
+func (m selectorModel) renderItem(s *strings.Builder, item SelectItem, idx int) {
+	if idx == m.cursor {
+		s.WriteString(selectorSelectedItemStyle.Render("▸ " + item.Name))
+	} else {
+		s.WriteString(selectorItemStyle.Render(item.Name))
 	}
+	s.WriteString("\n")
+	if item.Description != "" {
+		s.WriteString(selectorDescLineStyle.Render(item.Description))
+		s.WriteString("\n")
+	}
+}
 
+// renderContent renders the selector content (title, items, help text) without
+// checking the cancelled/selected state. This is used by both View() (standalone mode)
+// and by the TUI modal which embeds a selectorModel.
+func (m selectorModel) renderContent() string {
 	var s strings.Builder
 
-	// Title with filter
 	s.WriteString(selectorTitleStyle.Render(m.title))
 	s.WriteString(" ")
 	if m.filter == "" {
@@ -180,42 +261,91 @@ func (m selectorModel) View() string {
 	if len(filtered) == 0 {
 		s.WriteString(selectorItemStyle.Render(selectorDescStyle.Render("(no matches)")))
 		s.WriteString("\n")
-	} else {
-		displayCount := min(len(filtered), maxSelectorItems)
+	} else if m.filter != "" {
+		s.WriteString(sectionHeaderStyle.Render("Top Results"))
+		s.WriteString("\n")
 
+		displayCount := min(len(filtered), maxSelectorItems)
 		for i := range displayCount {
 			idx := m.scrollOffset + i
 			if idx >= len(filtered) {
 				break
 			}
-			item := filtered[idx]
-
-			if idx == m.cursor {
-				s.WriteString(selectorSelectedItemStyle.Render("▸ " + item.Name))
-			} else {
-				s.WriteString(selectorItemStyle.Render(item.Name))
-			}
-
-			if item.Description != "" {
-				s.WriteString(" ")
-				s.WriteString(selectorDescStyle.Render("- " + item.Description))
-			}
-			s.WriteString("\n")
+			m.renderItem(&s, filtered[idx], idx)
 		}
 
 		if remaining := len(filtered) - m.scrollOffset - displayCount; remaining > 0 {
 			s.WriteString(selectorMoreStyle.Render(fmt.Sprintf("... and %d more", remaining)))
 			s.WriteString("\n")
 		}
+	} else {
+		// Split into pinned recommended and scrollable others
+		var recItems, otherItems []int
+		for i, item := range filtered {
+			if item.Recommended {
+				recItems = append(recItems, i)
+			} else {
+				otherItems = append(otherItems, i)
+			}
+		}
+
+		// Always render all recommended items (pinned)
+		if len(recItems) > 0 {
+			s.WriteString(sectionHeaderStyle.Render("Recommended"))
+			s.WriteString("\n")
+			for _, idx := range recItems {
+				m.renderItem(&s, filtered[idx], idx)
+			}
+		}
+
+		if len(otherItems) > 0 {
+			s.WriteString("\n")
+			s.WriteString(sectionHeaderStyle.Render("More"))
+			s.WriteString("\n")
+
+			maxOthers := maxSelectorItems - len(recItems)
+			if maxOthers < 3 {
+				maxOthers = 3
+			}
+			displayCount := min(len(otherItems), maxOthers)
+
+			for i := range displayCount {
+				idx := m.scrollOffset + i
+				if idx >= len(otherItems) {
+					break
+				}
+				m.renderItem(&s, filtered[otherItems[idx]], otherItems[idx])
+			}
+
+			if remaining := len(otherItems) - m.scrollOffset - displayCount; remaining > 0 {
+				s.WriteString(selectorMoreStyle.Render(fmt.Sprintf("... and %d more", remaining)))
+				s.WriteString("\n")
+			}
+		}
 	}
 
 	s.WriteString("\n")
-	s.WriteString(selectorHelpStyle.Render("↑/↓ navigate • enter select • esc cancel"))
+	help := "↑/↓ navigate • enter select • esc cancel"
+	if m.helpText != "" {
+		help = m.helpText
+	}
+	s.WriteString(selectorHelpStyle.Render(help))
 
 	return s.String()
 }
 
-// SelectSingle prompts the user to select a single item from a list.
+func (m selectorModel) View() string {
+	if m.cancelled || m.selected != "" {
+		return ""
+	}
+
+	s := m.renderContent()
+	if m.width > 0 {
+		return lipgloss.NewStyle().MaxWidth(m.width).Render(s)
+	}
+	return s
+}
+
 func SelectSingle(title string, items []SelectItem) (string, error) {
 	if len(items) == 0 {
 		return "", fmt.Errorf("no items to select from")
@@ -252,6 +382,7 @@ type multiSelectorModel struct {
 	checkOrder   []int
 	cancelled    bool
 	confirmed    bool
+	width        int
 }
 
 func newMultiSelectorModel(title string, items []SelectItem, preChecked []string) multiSelectorModel {
@@ -323,6 +454,14 @@ func (m multiSelectorModel) Init() tea.Cmd {
 
 func (m multiSelectorModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 	switch msg := msg.(type) {
+	case tea.WindowSizeMsg:
+		wasSet := m.width > 0
+		m.width = msg.Width
+		if wasSet {
+			return m, tea.EnterAltScreen
+		}
+		return m, nil
+
 	case tea.KeyMsg:
 		filtered := m.filteredItems()
 
@@ -332,14 +471,12 @@ func (m multiSelectorModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 			return m, tea.Quit
 
 		case tea.KeyEnter:
-			// Enter confirms if at least one item is selected
 			if len(m.checkOrder) > 0 {
 				m.confirmed = true
 				return m, tea.Quit
 			}
 
 		case tea.KeySpace:
-			// Space always toggles selection
 			m.toggleItem()
 
 		case tea.KeyUp:
@@ -395,14 +532,12 @@ func (m multiSelectorModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 }
 
 func (m multiSelectorModel) View() string {
-	// Clear screen when exiting
 	if m.cancelled || m.confirmed {
 		return ""
 	}
 
 	var s strings.Builder
 
-	// Title with filter
 	s.WriteString(selectorTitleStyle.Render(m.title))
 	s.WriteString(" ")
 	if m.filter == "" {
@@ -419,6 +554,8 @@ func (m multiSelectorModel) View() string {
 		s.WriteString("\n")
 	} else {
 		displayCount := min(len(filtered), maxSelectorItems)
+		shownRecHeader := false
+		prevWasRec := false
 
 		for i := range displayCount {
 			idx := m.scrollOffset + i
@@ -428,7 +565,17 @@ func (m multiSelectorModel) View() string {
 			item := filtered[idx]
 			origIdx := m.itemIndex[item.Name]
 
-			// Checkbox
+			if m.filter == "" {
+				if item.Recommended && !shownRecHeader {
+					s.WriteString(sectionHeaderStyle.Render("Recommended"))
+					s.WriteString("\n")
+					shownRecHeader = true
+				} else if !item.Recommended && prevWasRec {
+					s.WriteString("\n")
+				}
+				prevWasRec = item.Recommended
+			}
+
 			var checkbox string
 			if m.checked[origIdx] {
 				checkbox = selectorCheckboxCheckedStyle.Render("[x]")
@@ -436,7 +583,6 @@ func (m multiSelectorModel) View() string {
 				checkbox = selectorCheckboxStyle.Render("[ ]")
 			}
 
-			// Cursor and name
 			var line string
 			if idx == m.cursor {
 				line = selectorSelectedItemStyle.Render("▸ ") + checkbox + " " + selectorSelectedItemStyle.Render(item.Name)
@@ -444,7 +590,6 @@ func (m multiSelectorModel) View() string {
 				line = "  " + checkbox + " " + item.Name
 			}
 
-			// Default tag
 			if len(m.checkOrder) > 0 && m.checkOrder[0] == origIdx {
 				line += " " + selectorDefaultTagStyle.Render("(default)")
 			}
@@ -461,7 +606,6 @@ func (m multiSelectorModel) View() string {
 
 	s.WriteString("\n")
 
-	// Status line
 	count := m.selectedCount()
 	if count == 0 {
 		s.WriteString(selectorDescStyle.Render("  Select at least one model."))
@@ -472,10 +616,13 @@ func (m multiSelectorModel) View() string {
 
 	s.WriteString(selectorHelpStyle.Render("↑/↓ navigate • space toggle • enter confirm • esc cancel"))
 
-	return s.String()
+	result := s.String()
+	if m.width > 0 {
+		return lipgloss.NewStyle().MaxWidth(m.width).Render(result)
+	}
+	return result
 }
 
-// SelectMultiple prompts the user to select multiple items from a list.
 func SelectMultiple(title string, items []SelectItem, preChecked []string) ([]string, error) {
 	if len(items) == 0 {
 		return nil, fmt.Errorf("no items to select from")

cmd/tui/selector_test.go

@@ -0,0 +1,410 @@
+package tui
+
+import (
+	"strings"
+	"testing"
+
+	tea "github.com/charmbracelet/bubbletea"
+)
+
+func items(names ...string) []SelectItem {
+	var out []SelectItem
+	for _, n := range names {
+		out = append(out, SelectItem{Name: n})
+	}
+	return out
+}
+
+func recItems(names ...string) []SelectItem {
+	var out []SelectItem
+	for _, n := range names {
+		out = append(out, SelectItem{Name: n, Recommended: true})
+	}
+	return out
+}
+
+func mixedItems() []SelectItem {
+	return []SelectItem{
+		{Name: "rec-a", Recommended: true},
+		{Name: "rec-b", Recommended: true},
+		{Name: "other-1"},
+		{Name: "other-2"},
+		{Name: "other-3"},
+		{Name: "other-4"},
+		{Name: "other-5"},
+		{Name: "other-6"},
+		{Name: "other-7"},
+		{Name: "other-8"},
+		{Name: "other-9"},
+		{Name: "other-10"},
+	}
+}
+
+func TestFilteredItems(t *testing.T) {
+	tests := []struct {
+		name   string
+		items  []SelectItem
+		filter string
+		want   []string
+	}{
+		{
+			name:   "no filter returns all",
+			items:  items("alpha", "beta", "gamma"),
+			filter: "",
+			want:   []string{"alpha", "beta", "gamma"},
+		},
+		{
+			name:   "filter matches substring",
+			items:  items("llama3.2", "qwen3:8b", "llama2"),
+			filter: "llama",
+			want:   []string{"llama3.2", "llama2"},
+		},
+		{
+			name:   "filter is case insensitive",
+			items:  items("Qwen3:8b", "llama3.2"),
+			filter: "QWEN",
+			want:   []string{"Qwen3:8b"},
+		},
+		{
+			name:   "no matches",
+			items:  items("alpha", "beta"),
+			filter: "zzz",
+			want:   nil,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			m := selectorModel{items: tt.items, filter: tt.filter}
+			got := m.filteredItems()
+			var gotNames []string
+			for _, item := range got {
+				gotNames = append(gotNames, item.Name)
+			}
+			if len(gotNames) != len(tt.want) {
+				t.Fatalf("got %v, want %v", gotNames, tt.want)
+			}
+			for i := range tt.want {
+				if gotNames[i] != tt.want[i] {
+					t.Errorf("index %d: got %q, want %q", i, gotNames[i], tt.want[i])
+				}
+			}
+		})
+	}
+}
+
+func TestOtherStart(t *testing.T) {
+	tests := []struct {
+		name   string
+		items  []SelectItem
+		filter string
+		want   int
+	}{
+		{
+			name:  "all recommended",
+			items: recItems("a", "b", "c"),
+			want:  3,
+		},
+		{
+			name:  "none recommended",
+			items: items("a", "b"),
+			want:  0,
+		},
+		{
+			name: "mixed",
+			items: []SelectItem{
+				{Name: "rec-a", Recommended: true},
+				{Name: "rec-b", Recommended: true},
+				{Name: "other-1"},
+				{Name: "other-2"},
+			},
+			want: 2,
+		},
+		{
+			name:  "empty",
+			items: nil,
+			want:  0,
+		},
+		{
+			name: "filtering returns 0",
+			items: []SelectItem{
+				{Name: "rec-a", Recommended: true},
+				{Name: "other-1"},
+			},
+			filter: "rec",
+			want:   0,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			m := selectorModel{items: tt.items, filter: tt.filter}
+			if got := m.otherStart(); got != tt.want {
+				t.Errorf("otherStart() = %d, want %d", got, tt.want)
+			}
+		})
+	}
+}
+
+func TestUpdateScroll(t *testing.T) {
+	tests := []struct {
+		name       string
+		cursor     int
+		offset     int
+		otherStart int
+		filter     string
+		wantOffset int
+	}{
+		{
+			name:       "cursor in recommended resets scroll",
+			cursor:     1,
+			offset:     5,
+			otherStart: 3,
+			wantOffset: 0,
+		},
+		{
+			name:       "cursor at start of others",
+			cursor:     2,
+			offset:     0,
+			otherStart: 2,
+			wantOffset: 0,
+		},
+		{
+			name:       "cursor scrolls down in others",
+			cursor:     12,
+			offset:     0,
+			otherStart: 2,
+			wantOffset: 3, // posInOthers=10, maxOthers=8, 10-8+1=3
+		},
+		{
+			name:       "cursor scrolls up in others",
+			cursor:     4,
+			offset:     5,
+			otherStart: 2,
+			wantOffset: 2, // posInOthers=2 < offset=5
+		},
+		{
+			name:       "filter mode standard scroll down",
+			cursor:     12,
+			offset:     0,
+			filter:     "x",
+			otherStart: 0,
+			wantOffset: 3, // 12 - 10 + 1 = 3
+		},
+		{
+			name:       "filter mode standard scroll up",
+			cursor:     2,
+			offset:     5,
+			filter:     "x",
+			otherStart: 0,
+			wantOffset: 2,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			m := selectorModel{
+				cursor:       tt.cursor,
+				scrollOffset: tt.offset,
+				filter:       tt.filter,
+			}
+			m.updateScroll(tt.otherStart)
+			if m.scrollOffset != tt.wantOffset {
+				t.Errorf("scrollOffset = %d, want %d", m.scrollOffset, tt.wantOffset)
+			}
+		})
+	}
+}
+
+func TestRenderContent_SectionHeaders(t *testing.T) {
+	m := selectorModel{
+		title: "Pick:",
+		items: []SelectItem{
+			{Name: "rec-a", Recommended: true},
+			{Name: "other-1"},
+		},
+	}
+	content := m.renderContent()
+
+	if !strings.Contains(content, "Recommended") {
+		t.Error("should contain 'Recommended' header")
+	}
+	if !strings.Contains(content, "More") {
+		t.Error("should contain 'More' header")
+	}
+}
+
+func TestRenderContent_FilteredHeader(t *testing.T) {
+	m := selectorModel{
+		title:  "Pick:",
+		items:  items("alpha", "beta", "alphabet"),
+		filter: "alpha",
+	}
+	content := m.renderContent()
+
+	if !strings.Contains(content, "Top Results") {
+		t.Error("filtered view should contain 'Top Results' header")
+	}
+	if strings.Contains(content, "Recommended") {
+		t.Error("filtered view should not contain 'Recommended' header")
+	}
+}
+
+func TestRenderContent_NoMatches(t *testing.T) {
+	m := selectorModel{
+		title:  "Pick:",
+		items:  items("alpha"),
+		filter: "zzz",
+	}
+	content := m.renderContent()
+
+	if !strings.Contains(content, "(no matches)") {
+		t.Error("should show '(no matches)' when filter has no results")
+	}
+}
+
+func TestRenderContent_SelectedItemIndicator(t *testing.T) {
+	m := selectorModel{
+		title:  "Pick:",
+		items:  items("alpha", "beta"),
+		cursor: 0,
+	}
+	content := m.renderContent()
+
+	if !strings.Contains(content, "▸") {
+		t.Error("selected item should have ▸ indicator")
+	}
+}
+
+func TestRenderContent_Description(t *testing.T) {
+	m := selectorModel{
+		title: "Pick:",
+		items: []SelectItem{
+			{Name: "alpha", Description: "the first letter"},
+		},
+	}
+	content := m.renderContent()
+
+	if !strings.Contains(content, "the first letter") {
+		t.Error("should render item description")
+	}
+}
+
+func TestRenderContent_PinnedRecommended(t *testing.T) {
+	m := selectorModel{
+		title: "Pick:",
+		items: mixedItems(),
+		// cursor deep in "More" section
+		cursor:       8,
+		scrollOffset: 3,
+	}
+	content := m.renderContent()
+
+	// Recommended items should always be visible (pinned)
+	if !strings.Contains(content, "rec-a") {
+		t.Error("recommended items should always be rendered (pinned)")
+	}
+	if !strings.Contains(content, "rec-b") {
+		t.Error("recommended items should always be rendered (pinned)")
+	}
+}
+
+func TestRenderContent_MoreOverflowIndicator(t *testing.T) {
+	m := selectorModel{
+		title: "Pick:",
+		items: mixedItems(), // 2 rec + 10 other = 12 total, maxSelectorItems=10
+	}
+	content := m.renderContent()
+
+	if !strings.Contains(content, "... and") {
+		t.Error("should show overflow indicator when more items than visible")
+	}
+}
+
+func TestUpdateNavigation_CursorBounds(t *testing.T) {
+	m := selectorModel{
+		items:  items("a", "b", "c"),
+		cursor: 0,
+	}
+
+	// Up at top stays at 0
+	m.updateNavigation(keyMsg(KeyUp))
+	if m.cursor != 0 {
+		t.Errorf("cursor should stay at 0 when pressing up at top, got %d", m.cursor)
+	}
+
+	// Down moves to 1
+	m.updateNavigation(keyMsg(KeyDown))
+	if m.cursor != 1 {
+		t.Errorf("cursor should be 1 after down, got %d", m.cursor)
+	}
+
+	// Down to end
+	m.updateNavigation(keyMsg(KeyDown))
+	m.updateNavigation(keyMsg(KeyDown))
+	if m.cursor != 2 {
+		t.Errorf("cursor should be 2 at bottom, got %d", m.cursor)
+	}
+}
+
+func TestUpdateNavigation_FilterResetsState(t *testing.T) {
+	m := selectorModel{
+		items:        items("alpha", "beta"),
+		cursor:       1,
+		scrollOffset: 5,
+	}
+
+	m.updateNavigation(runeMsg('x'))
+	if m.filter != "x" {
+		t.Errorf("filter should be 'x', got %q", m.filter)
+	}
+	if m.cursor != 0 {
+		t.Errorf("cursor should reset to 0 on filter, got %d", m.cursor)
+	}
+	if m.scrollOffset != 0 {
+		t.Errorf("scrollOffset should reset to 0 on filter, got %d", m.scrollOffset)
+	}
+}
+
+func TestUpdateNavigation_Backspace(t *testing.T) {
+	m := selectorModel{
+		items:  items("alpha"),
+		filter: "abc",
+		cursor: 1,
+	}
+
+	m.updateNavigation(keyMsg(KeyBackspace))
+	if m.filter != "ab" {
+		t.Errorf("filter should be 'ab' after backspace, got %q", m.filter)
+	}
+	if m.cursor != 0 {
+		t.Errorf("cursor should reset to 0 on backspace, got %d", m.cursor)
+	}
+}
+
+// Key message helpers for testing
+
+type keyType = int
+
+const (
+	KeyUp        keyType = iota
+	KeyDown      keyType = iota
+	KeyBackspace keyType = iota
+)
+
+func keyMsg(k keyType) tea.KeyMsg {
+	switch k {
+	case KeyUp:
+		return tea.KeyMsg{Type: tea.KeyUp}
+	case KeyDown:
+		return tea.KeyMsg{Type: tea.KeyDown}
+	case KeyBackspace:
+		return tea.KeyMsg{Type: tea.KeyBackspace}
+	default:
+		return tea.KeyMsg{}
+	}
+}
+
+func runeMsg(r rune) tea.KeyMsg {
+	return tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{r}}
+}

cmd/tui/signin.go

@@ -0,0 +1,128 @@
+package tui
+
+import (
+	"fmt"
+	"strings"
+	"time"
+
+	tea "github.com/charmbracelet/bubbletea"
+	"github.com/charmbracelet/lipgloss"
+	"github.com/ollama/ollama/cmd/config"
+)
+
+type signInModel struct {
+	modelName string
+	signInURL string
+	spinner   int
+	width     int
+	userName  string
+	cancelled bool
+}
+
+func (m signInModel) Init() tea.Cmd {
+	return tea.Tick(200*time.Millisecond, func(t time.Time) tea.Msg {
+		return signInTickMsg{}
+	})
+}
+
+func (m signInModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
+	switch msg := msg.(type) {
+	case tea.WindowSizeMsg:
+		wasSet := m.width > 0
+		m.width = msg.Width
+		if wasSet {
+			return m, tea.EnterAltScreen
+		}
+		return m, nil
+
+	case tea.KeyMsg:
+		switch msg.Type {
+		case tea.KeyCtrlC, tea.KeyEsc:
+			m.cancelled = true
+			return m, tea.Quit
+		}
+
+	case signInTickMsg:
+		m.spinner++
+		if m.spinner%5 == 0 {
+			return m, tea.Batch(
+				tea.Tick(200*time.Millisecond, func(t time.Time) tea.Msg {
+					return signInTickMsg{}
+				}),
+				checkSignIn,
+			)
+		}
+		return m, tea.Tick(200*time.Millisecond, func(t time.Time) tea.Msg {
+			return signInTickMsg{}
+		})
+
+	case signInCheckMsg:
+		if msg.signedIn {
+			m.userName = msg.userName
+			return m, tea.Quit
+		}
+	}
+
+	return m, nil
+}
+
+func (m signInModel) View() string {
+	if m.userName != "" {
+		return ""
+	}
+	return renderSignIn(m.modelName, m.signInURL, m.spinner, m.width)
+}
+
+func renderSignIn(modelName, signInURL string, spinner, width int) string {
+	spinnerFrames := []string{"⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"}
+	frame := spinnerFrames[spinner%len(spinnerFrames)]
+
+	urlColor := lipgloss.NewStyle().
+		Foreground(lipgloss.Color("117"))
+	urlWrap := lipgloss.NewStyle().PaddingLeft(2)
+	if width > 4 {
+		urlWrap = urlWrap.Width(width - 4)
+	}
+
+	var s strings.Builder
+
+	fmt.Fprintf(&s, "To use %s, please sign in.\n\n", selectorSelectedItemStyle.Render(modelName))
+
+	// Wrap in OSC 8 hyperlink so the entire URL is clickable even when wrapped.
+	// Padding is outside the hyperlink so spaces don't get underlined.
+	link := fmt.Sprintf("\033]8;;%s\033\\%s\033]8;;\033\\", signInURL, urlColor.Render(signInURL))
+	s.WriteString("Navigate to:\n")
+	s.WriteString(urlWrap.Render(link))
+	s.WriteString("\n\n")
+
+	s.WriteString(lipgloss.NewStyle().Foreground(lipgloss.AdaptiveColor{Light: "242", Dark: "246"}).Render(
+		frame + " Waiting for sign in to complete..."))
+	s.WriteString("\n\n")
+
+	s.WriteString(selectorHelpStyle.Render("esc cancel"))
+
+	return lipgloss.NewStyle().PaddingLeft(2).Render(s.String())
+}
+
+// RunSignIn shows a bubbletea sign-in dialog and polls until the user signs in or cancels.
+func RunSignIn(modelName, signInURL string) (string, error) {
+	config.OpenBrowser(signInURL)
+
+	m := signInModel{
+		modelName: modelName,
+		signInURL: signInURL,
+	}
+
+	p := tea.NewProgram(m)
+	finalModel, err := p.Run()
+	if err != nil {
+		return "", fmt.Errorf("error running sign-in: %w", err)
+	}
+
+	fm := finalModel.(signInModel)
+	if fm.cancelled {
+		return "", ErrCancelled
+	}
+
+	return fm.userName, nil
+}

cmd/tui/signin_test.go

@@ -0,0 +1,175 @@
+package tui
+
+import (
+	"strings"
+	"testing"
+
+	tea "github.com/charmbracelet/bubbletea"
+)
+
+func TestRenderSignIn_ContainsModelName(t *testing.T) {
+	got := renderSignIn("glm-4.7:cloud", "https://example.com/signin", 0, 80)
+	if !strings.Contains(got, "glm-4.7:cloud") {
+		t.Error("should contain model name")
+	}
+	if !strings.Contains(got, "please sign in") {
+		t.Error("should contain sign-in prompt")
+	}
+}
+
+func TestRenderSignIn_ContainsURL(t *testing.T) {
+	url := "https://ollama.com/connect?key=abc123"
+	got := renderSignIn("test:cloud", url, 0, 120)
+	if !strings.Contains(got, url) {
+		t.Errorf("should contain URL %q", url)
+	}
+}
+
+func TestRenderSignIn_OSC8Hyperlink(t *testing.T) {
+	url := "https://ollama.com/connect?key=abc123"
+	got := renderSignIn("test:cloud", url, 0, 120)
+
+	// Should contain OSC 8 open sequence with the URL
+	osc8Open := "\033]8;;" + url + "\033\\"
+	if !strings.Contains(got, osc8Open) {
+		t.Error("should contain OSC 8 open sequence with URL")
+	}
+
+	// Should contain OSC 8 close sequence
+	osc8Close := "\033]8;;\033\\"
+	if !strings.Contains(got, osc8Close) {
+		t.Error("should contain OSC 8 close sequence")
+	}
+}
+
+func TestRenderSignIn_ContainsSpinner(t *testing.T) {
+	got := renderSignIn("test:cloud", "https://example.com", 0, 80)
+	if !strings.Contains(got, "Waiting for sign in to complete") {
+		t.Error("should contain waiting message")
+	}
+	if !strings.Contains(got, "⠋") {
+		t.Error("should contain first spinner frame at spinner=0")
+	}
+}
+
+func TestRenderSignIn_SpinnerAdvances(t *testing.T) {
+	got0 := renderSignIn("test:cloud", "https://example.com", 0, 80)
+	got1 := renderSignIn("test:cloud", "https://example.com", 1, 80)
+	if got0 == got1 {
+		t.Error("different spinner values should produce different output")
+	}
+}
+
+func TestRenderSignIn_ContainsEscHelp(t *testing.T) {
+	got := renderSignIn("test:cloud", "https://example.com", 0, 80)
+	if !strings.Contains(got, "esc cancel") {
+		t.Error("should contain esc cancel help text")
+	}
+}
+
+func TestSignInModel_EscCancels(t *testing.T) {
+	m := signInModel{
+		modelName: "test:cloud",
+		signInURL: "https://example.com",
+	}
+
+	updated, cmd := m.Update(tea.KeyMsg{Type: tea.KeyEsc})
+	fm := updated.(signInModel)
+	if !fm.cancelled {
+		t.Error("esc should set cancelled=true")
+	}
+	if cmd == nil {
+		t.Error("esc should return tea.Quit")
+	}
+}
+
+func TestSignInModel_CtrlCCancels(t *testing.T) {
+	m := signInModel{
+		modelName: "test:cloud",
+		signInURL: "https://example.com",
+	}
+
+	updated, cmd := m.Update(tea.KeyMsg{Type: tea.KeyCtrlC})
+	fm := updated.(signInModel)
+	if !fm.cancelled {
+		t.Error("ctrl+c should set cancelled=true")
+	}
+	if cmd == nil {
+		t.Error("ctrl+c should return tea.Quit")
+	}
+}
+
+func TestSignInModel_SignedInQuitsClean(t *testing.T) {
+	m := signInModel{
+		modelName: "test:cloud",
+		signInURL: "https://example.com",
+	}
+
+	updated, cmd := m.Update(signInCheckMsg{signedIn: true, userName: "alice"})
+	fm := updated.(signInModel)
+	if fm.userName != "alice" {
+		t.Errorf("expected userName 'alice', got %q", fm.userName)
+	}
+	if cmd == nil {
+		t.Error("successful sign-in should return tea.Quit")
+	}
+}
+
+func TestSignInModel_SignedInViewClears(t *testing.T) {
+	m := signInModel{
+		modelName: "test:cloud",
+		signInURL: "https://example.com",
+		userName:  "alice",
+	}
+
+	got := m.View()
+	if got != "" {
+		t.Errorf("View should return empty string after sign-in, got %q", got)
+	}
+}
+
+func TestSignInModel_NotSignedInContinues(t *testing.T) {
+	m := signInModel{
+		modelName: "test:cloud",
+		signInURL: "https://example.com",
+	}
+
+	updated, _ := m.Update(signInCheckMsg{signedIn: false})
+	fm := updated.(signInModel)
+	if fm.userName != "" {
+		t.Error("should not set userName when not signed in")
+	}
+	if fm.cancelled {
+		t.Error("should not cancel when check returns not signed in")
+	}
+}
+
+func TestSignInModel_WindowSizeUpdatesWidth(t *testing.T) {
+	m := signInModel{
+		modelName: "test:cloud",
+		signInURL: "https://example.com",
+	}
+
+	updated, _ := m.Update(tea.WindowSizeMsg{Width: 120, Height: 40})
+	fm := updated.(signInModel)
+	if fm.width != 120 {
+		t.Errorf("expected width 120, got %d", fm.width)
+	}
+}
+
+func TestSignInModel_TickAdvancesSpinner(t *testing.T) {
+	m := signInModel{
+		modelName: "test:cloud",
+		signInURL: "https://example.com",
+		spinner:   0,
+	}
+
+	updated, cmd := m.Update(signInTickMsg{})
+	fm := updated.(signInModel)
+	if fm.spinner != 1 {
+		t.Errorf("expected spinner=1, got %d", fm.spinner)
+	}
+	if cmd == nil {
+		t.Error("tick should return a command")
+	}
+}

cmd/tui/tui.go

@@ -4,8 +4,6 @@ import (
 	"context"
 	"errors"
 	"fmt"
-	"os/exec"
-	"runtime"
 	"strings"
 	"time"
 
@@ -17,37 +15,30 @@ import (
 )
 
 var (
-	titleStyle = lipgloss.NewStyle().
-			Bold(true).
-			MarginBottom(1)
-
 	versionStyle = lipgloss.NewStyle().
-			Foreground(lipgloss.Color("245"))
+			Foreground(lipgloss.AdaptiveColor{Light: "243", Dark: "250"})
 
-	itemStyle = lipgloss.NewStyle().
+	menuItemStyle = lipgloss.NewStyle().
 			PaddingLeft(2)
 
-	selectedStyle = lipgloss.NewStyle().
-			PaddingLeft(2).
-			Bold(true)
+	menuSelectedItemStyle = lipgloss.NewStyle().
+				Bold(true).
+				Background(lipgloss.AdaptiveColor{Light: "254", Dark: "236"})
 
-	greyedStyle = lipgloss.NewStyle().
-			PaddingLeft(2).
-			Foreground(lipgloss.Color("241"))
+	menuDescStyle = selectorDescStyle.
+			PaddingLeft(4)
 
-	greyedSelectedStyle = lipgloss.NewStyle().
-				PaddingLeft(2).
-				Foreground(lipgloss.Color("243"))
+	greyedStyle = menuItemStyle.
+			Foreground(lipgloss.AdaptiveColor{Light: "242", Dark: "246"})
 
-	descStyle = lipgloss.NewStyle().
-			PaddingLeft(4).
-			Foreground(lipgloss.Color("241"))
+	greyedSelectedStyle = menuSelectedItemStyle.
+				Foreground(lipgloss.AdaptiveColor{Light: "242", Dark: "246"})
 
 	modelStyle = lipgloss.NewStyle().
-			Foreground(lipgloss.Color("245"))
+			Foreground(lipgloss.AdaptiveColor{Light: "243", Dark: "250"})
 
 	notInstalledStyle = lipgloss.NewStyle().
-				Foreground(lipgloss.Color("241")).
+				Foreground(lipgloss.AdaptiveColor{Light: "242", Dark: "246"}).
 				Italic(true)
 )
 
@@ -55,94 +46,102 @@ type menuItem struct {
 	title       string
 	description string
 	integration string // integration name for loading model config, empty if not an integration
-	isRunModel  bool   // true for the "Run a model" option
-	isOthers    bool   // true for the "Others..." toggle item
+	isRunModel  bool
+	isOthers    bool
 }
 
 var mainMenuItems = []menuItem{
 	{
 		title:       "Run a model",
-		description: "Start an interactive chat with a local model",
+		description: "Start an interactive chat with a model",
 		isRunModel:  true,
 	},
 	{
 		title:       "Launch Claude Code",
-		description: "Open Claude Code AI assistant",
+		description: "Agentic coding across large codebases",
 		integration: "claude",
 	},
 	{
 		title:       "Launch Codex",
-		description: "Open Codex CLI",
+		description: "OpenAI's open-source coding agent",
 		integration: "codex",
 	},
 	{
-		title:       "Launch Open Claw",
-		description: "Open the Open Claw integration",
+		title:       "Launch OpenClaw",
+		description: "Personal AI with 100+ skills",
 		integration: "openclaw",
 	},
 }
 
 var othersMenuItem = menuItem{
-	title:       "Others...",
+	title:       "More...",
 	description: "Show additional integrations",
 	isOthers:    true,
 }
 
-// getOtherIntegrations returns the list of other integrations, filtering out
-// Codex if it's not installed (since it requires npm install).
+// getOtherIntegrations dynamically builds the "Others" list from the integration
+// registry, excluding any integrations already present in the pinned mainMenuItems.
 func getOtherIntegrations() []menuItem {
-	return []menuItem{
-		{
-			title:       "Launch Droid",
-			description: "Open Droid integration",
-			integration: "droid",
-		},
-		{
-			title:       "Launch Open Code",
-			description: "Open Open Code integration",
-			integration: "opencode",
-		},
-		{
-			title:       "Launch Pi",
-			description: "Open Pi coding agent",
-			integration: "pi",
-		},
+	pinned := map[string]bool{
+		"run": true, // not an integration but in the pinned list
 	}
+	for _, item := range mainMenuItems {
+		if item.integration != "" {
+			pinned[item.integration] = true
+		}
+	}
+
+	var others []menuItem
+	for _, info := range config.ListIntegrationInfos() {
+		if pinned[info.Name] {
+			continue
+		}
+		desc := info.Description
+		if desc == "" {
+			desc = "Open " + info.DisplayName + " integration"
+		}
+		others = append(others, menuItem{
+			title:       "Launch " + info.DisplayName,
+			description: desc,
+			integration: info.Name,
+		})
+	}
+	return others
 }
 
 type model struct {
 	items           []menuItem
 	cursor          int
 	quitting        bool
-	selected        bool            // true if user made a selection (enter/space)
-	changeModel     bool            // true if user pressed right arrow to change model
-	showOthers      bool            // true if "Others..." is expanded
-	availableModels map[string]bool // cache of available model names
+	selected        bool
+	changeModel     bool
+	showOthers      bool
+	availableModels map[string]bool
 	err             error
 
-	// Modal state
-	showingModal  bool          // true when model picker modal is visible
-	modalSelector selectorModel // the selector model for the modal
-	modalItems    []SelectItem  // cached items for the modal
+	showingModal  bool
+	modalSelector selectorModel
+	modalItems    []SelectItem
 
-	// Sign-in dialog state
-	showingSignIn   bool   // true when sign-in dialog is visible
-	signInURL       string // URL for sign-in
-	signInModel     string // model that requires sign-in
-	signInSpinner   int    // spinner frame index
+	showingSignIn   bool
+	signInURL       string
+	signInModel     string
+	signInSpinner   int
 	signInFromModal bool   // true if sign-in was triggered from modal (not main menu)
+
+	width     int    // terminal width from WindowSizeMsg
+	statusMsg string // temporary status message shown near help text
 }
 
-// signInTickMsg is sent to animate the sign-in spinner
 type signInTickMsg struct{}
 
-// signInCheckMsg is sent to check if sign-in is complete
 type signInCheckMsg struct {
 	signedIn bool
 	userName string
 }
 
-// modelExists checks if a model exists in the cached available models.
+type clearStatusMsg struct{}
+
 func (m *model) modelExists(name string) bool {
 	if m.availableModels == nil || name == "" {
 		return false
@@ -159,27 +158,25 @@ func (m *model) modelExists(name string) bool {
 	return false
 }
 
-// buildModalItems creates the list of models for the modal selector.
 func (m *model) buildModalItems() []SelectItem {
 	modelItems, _ := config.GetModelItems(context.Background())
 	var items []SelectItem
 	for _, item := range modelItems {
-		items = append(items, SelectItem{Name: item.Name, Description: item.Description})
+		items = append(items, SelectItem{Name: item.Name, Description: item.Description, Recommended: item.Recommended})
 	}
 	return items
 }
 
-// openModelModal opens the model picker modal.
 func (m *model) openModelModal() {
 	m.modalItems = m.buildModalItems()
 	m.modalSelector = selectorModel{
-		title: "Select model:",
-		items: m.modalItems,
+		title:    "Select model:",
+		items:    m.modalItems,
+		helpText: "↑/↓ navigate • enter select • ← back",
 	}
 	m.showingModal = true
 }
 
-// isCloudModel returns true if the model name indicates a cloud model.
 func isCloudModel(name string) bool {
 	return strings.HasSuffix(name, ":cloud")
 }
@@ -196,7 +193,7 @@ func (m *model) checkCloudSignIn(modelName string, fromModal bool) tea.Cmd {
 	}
 	user, err := client.Whoami(context.Background())
 	if err == nil && user != nil && user.Name != "" {
-		return nil // Already signed in
+		return nil
 	}
 	var aErr api.AuthorizationError
 	if errors.As(err, &aErr) && aErr.SigninURL != "" {
@@ -215,23 +212,13 @@ func (m *model) startSignIn(modelName, signInURL string, fromModal bool) tea.Cmd
 	m.signInSpinner = 0
 	m.signInFromModal = fromModal
 
-	// Open browser (best effort)
-	switch runtime.GOOS {
-	case "darwin":
-		_ = exec.Command("open", signInURL).Start()
-	case "linux":
-		_ = exec.Command("xdg-open", signInURL).Start()
-	case "windows":
-		_ = exec.Command("rundll32", "url.dll,FileProtocolHandler", signInURL).Start()
-	}
+	config.OpenBrowser(signInURL)
 
-	// Start the spinner tick
 	return tea.Tick(200*time.Millisecond, func(t time.Time) tea.Msg {
 		return signInTickMsg{}
 	})
 }
 
-// checkSignIn checks if the user has completed sign-in.
 func checkSignIn() tea.Msg {
 	client, err := api.ClientFromEnvironment()
 	if err != nil {
@@ -244,7 +231,6 @@ func checkSignIn() tea.Msg {
 	return signInCheckMsg{signedIn: false}
 }
 
-// loadAvailableModels fetches and caches the list of available models.
 func (m *model) loadAvailableModels() {
 	m.availableModels = make(map[string]bool)
 	client, err := api.ClientFromEnvironment()
@@ -266,24 +252,17 @@ func (m *model) buildItems() {
 	m.items = append(m.items, mainMenuItems...)
 
 	if m.showOthers {
-		// Change "Others..." to "Hide others..."
-		hideItem := menuItem{
-			title:       "Hide others...",
-			description: "Hide additional integrations",
-			isOthers:    true,
-		}
-		m.items = append(m.items, hideItem)
 		m.items = append(m.items, others...)
 	} else {
 		m.items = append(m.items, othersMenuItem)
 	}
 }
 
-// isOthersIntegration returns true if the integration is in the "Others" menu
 func isOthersIntegration(name string) bool {
-	switch name {
-	case "droid", "opencode":
-		return true
+	for _, item := range getOtherIntegrations() {
+		if item.integration == name {
+			return true
+		}
 	}
 	return false
 }
@@ -294,7 +273,6 @@ func initialModel() model {
 	}
 	m.loadAvailableModels()
 
-	// Check last selection to determine if we need to expand "Others"
 	lastSelection := config.LastSelection()
 	if isOthersIntegration(lastSelection) {
 		m.showOthers = true
@@ -302,7 +280,6 @@ func initialModel() model {
 
 	m.buildItems()
 
-	// Position cursor on last selection
 	if lastSelection != "" {
 		for i, item := range m.items {
 			if lastSelection == "run" && item.isRunModel {
@@ -323,18 +300,29 @@ func (m model) Init() tea.Cmd {
 }
 
 func (m model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
-	// Handle sign-in dialog
+	if wmsg, ok := msg.(tea.WindowSizeMsg); ok {
+		wasSet := m.width > 0
+		m.width = wmsg.Width
+		if wasSet {
+			return m, tea.EnterAltScreen
+		}
+		return m, nil
+	}
+
+	if _, ok := msg.(clearStatusMsg); ok {
+		m.statusMsg = ""
+		return m, nil
+	}
+
 	if m.showingSignIn {
 		switch msg := msg.(type) {
 		case tea.KeyMsg:
 			switch msg.Type {
 			case tea.KeyCtrlC, tea.KeyEsc:
-				// Cancel sign-in and go back
 				m.showingSignIn = false
 				if m.signInFromModal {
 					m.showingModal = true
 				}
-				// If from main menu, just return to main menu (default state)
 				return m, nil
 			}
 
@@ -355,13 +343,10 @@ func (m model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 
 		case signInCheckMsg:
 			if msg.signedIn {
-				// Sign-in complete - proceed with selection
 				if m.signInFromModal {
-					// Came from modal - set changeModel
 					m.modalSelector.selected = m.signInModel
 					m.changeModel = true
 				} else {
-					// Came from main menu - just select
 					m.selected = true
 				}
 				m.quitting = true
@@ -371,13 +356,11 @@ func (m model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 		return m, nil
 	}
 
-	// Handle modal input if modal is showing
 	if m.showingModal {
 		switch msg := msg.(type) {
 		case tea.KeyMsg:
 			switch msg.Type {
-			case tea.KeyCtrlC, tea.KeyEsc:
-				// Close modal without selection
+			case tea.KeyCtrlC, tea.KeyEsc, tea.KeyLeft:
 				m.showingModal = false
 				return m, nil
 
@@ -390,63 +373,15 @@ func (m model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 					if cmd := m.checkCloudSignIn(m.modalSelector.selected, true); cmd != nil {
 						return m, cmd
 					}
-					// Selection made - exit with changeModel
 					m.changeModel = true
 					m.quitting = true
 					return m, tea.Quit
 				}
 				return m, nil
 
-			case tea.KeyUp:
-				if m.modalSelector.cursor > 0 {
-					m.modalSelector.cursor--
-					if m.modalSelector.cursor < m.modalSelector.scrollOffset {
-						m.modalSelector.scrollOffset = m.modalSelector.cursor
-					}
-				}
-
-			case tea.KeyDown:
-				filtered := m.modalSelector.filteredItems()
-				if m.modalSelector.cursor < len(filtered)-1 {
-					m.modalSelector.cursor++
-					if m.modalSelector.cursor >= m.modalSelector.scrollOffset+maxSelectorItems {
-						m.modalSelector.scrollOffset = m.modalSelector.cursor - maxSelectorItems + 1
-					}
-				}
-
-			case tea.KeyPgUp:
-				filtered := m.modalSelector.filteredItems()
-				m.modalSelector.cursor -= maxSelectorItems
-				if m.modalSelector.cursor < 0 {
-					m.modalSelector.cursor = 0
-				}
-				m.modalSelector.scrollOffset -= maxSelectorItems
-				if m.modalSelector.scrollOffset < 0 {
-					m.modalSelector.scrollOffset = 0
-				}
-				_ = filtered // suppress unused warning
-
-			case tea.KeyPgDown:
-				filtered := m.modalSelector.filteredItems()
-				m.modalSelector.cursor += maxSelectorItems
-				if m.modalSelector.cursor >= len(filtered) {
-					m.modalSelector.cursor = len(filtered) - 1
-				}
-				if m.modalSelector.cursor >= m.modalSelector.scrollOffset+maxSelectorItems {
-					m.modalSelector.scrollOffset = m.modalSelector.cursor - maxSelectorItems + 1
-				}
-
-			case tea.KeyBackspace:
-				if len(m.modalSelector.filter) > 0 {
-					m.modalSelector.filter = m.modalSelector.filter[:len(m.modalSelector.filter)-1]
-					m.modalSelector.cursor = 0
-					m.modalSelector.scrollOffset = 0
-				}
-
-			case tea.KeyRunes:
-				m.modalSelector.filter += string(msg.Runes)
-				m.modalSelector.cursor = 0
-				m.modalSelector.scrollOffset = 0
+			default:
+				// Delegate navigation (up/down/pgup/pgdown/filter/backspace) to selectorModel
+				m.modalSelector.updateNavigation(msg)
 			}
 		}
 		return m, nil
@@ -463,32 +398,30 @@ func (m model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 			if m.cursor > 0 {
 				m.cursor--
 			}
+			// Auto-collapse "Others" when cursor moves back into pinned items
+			if m.showOthers && m.cursor < len(mainMenuItems) {
+				m.showOthers = false
+				m.buildItems()
+			}
 
 		case "down", "j":
 			if m.cursor < len(m.items)-1 {
 				m.cursor++
 			}
+			// Auto-expand "Others..." when cursor lands on it
+			if m.cursor < len(m.items) && m.items[m.cursor].isOthers && !m.showOthers {
+				m.showOthers = true
+				m.buildItems()
+				// cursor now points at the first "other" integration
+			}
 
 		case "enter", " ":
 			item := m.items[m.cursor]
 
-			// Handle "Others..." toggle
-			if item.isOthers {
-				m.showOthers = !m.showOthers
-				m.buildItems()
-				// Keep cursor on the Others/Hide item
-				if m.cursor >= len(m.items) {
-					m.cursor = len(m.items) - 1
-				}
-				return m, nil
-			}
-
-			// Don't allow selecting uninstalled integrations
 			if item.integration != "" && !config.IsIntegrationInstalled(item.integration) {
 				return m, nil
 			}
 
-			// Check if a cloud model is configured and needs sign-in
 			var configuredModel string
 			if item.isRunModel {
 				configuredModel = config.LastModel()
@@ -504,10 +437,8 @@ func (m model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 			return m, tea.Quit
 
 		case "right", "l":
-			// Allow model change for integrations and run model
 			item := m.items[m.cursor]
 			if item.integration != "" || item.isRunModel {
-				// Don't allow for uninstalled integrations
 				if item.integration != "" && !config.IsIntegrationInstalled(item.integration) {
 					return m, nil
 				}
@@ -524,21 +455,19 @@ func (m model) View() string {
 		return ""
 	}
 
-	// Render sign-in dialog if showing
 	if m.showingSignIn {
 		return m.renderSignInDialog()
 	}
 
-	// Render modal overlay if showing - replaces main view
 	if m.showingModal {
 		return m.renderModal()
 	}
 
-	s := titleStyle.Render("  Ollama "+versionStyle.Render("v"+version.Version)) + "\n\n"
+	s := selectorTitleStyle.Render("Ollama "+versionStyle.Render(version.Version)) + "\n\n"
 
 	for i, item := range m.items {
-		cursor := "  "
-		style := itemStyle
+		cursor := ""
+		style := menuItemStyle
 		isInstalled := true
 
 		if item.integration != "" {
@@ -548,7 +477,7 @@ func (m model) View() string {
 		if m.cursor == i {
 			cursor = "▸ "
 			if isInstalled {
-				style = selectedStyle
+				style = menuSelectedItemStyle
 			} else {
 				style = greyedSelectedStyle
 			}
@@ -557,119 +486,62 @@ func (m model) View() string {
 		}
 
 		title := item.title
+		var modelSuffix string
 		if item.integration != "" {
 			if !isInstalled {
 				title += " " + notInstalledStyle.Render("(not installed)")
-			} else if mdl := config.IntegrationModel(item.integration); mdl != "" && m.modelExists(mdl) {
-				title += " " + modelStyle.Render("("+mdl+")")
+			} else if m.cursor == i {
+				if mdl := config.IntegrationModel(item.integration); mdl != "" && m.modelExists(mdl) {
+					modelSuffix = " " + modelStyle.Render("("+mdl+")")
+				}
 			}
-		} else if item.isRunModel {
+		} else if item.isRunModel && m.cursor == i {
 			if mdl := config.LastModel(); mdl != "" && m.modelExists(mdl) {
-				title += " " + modelStyle.Render("("+mdl+")")
+				modelSuffix = " " + modelStyle.Render("("+mdl+")")
 			}
 		}
 
-		s += style.Render(cursor+title) + "\n"
-		s += descStyle.Render(item.description) + "\n\n"
+		s += style.Render(cursor+title) + modelSuffix + "\n"
+
+		desc := item.description
+		if !isInstalled && item.integration != "" && m.cursor == i {
+			if hint := config.IntegrationInstallHint(item.integration); hint != "" {
+				desc = hint
+			} else {
+				desc = "not installed"
+			}
+		}
+		s += menuDescStyle.Render(desc) + "\n\n"
 	}
 
-	s += "\n" + lipgloss.NewStyle().Foreground(lipgloss.Color("241")).Render("↑/↓ navigate • enter select • → change model • esc quit")
+	if m.statusMsg != "" {
+		s += "\n" + lipgloss.NewStyle().Foreground(lipgloss.AdaptiveColor{Light: "124", Dark: "210"}).Render(m.statusMsg) + "\n"
+	}
 
+	s += "\n" + selectorHelpStyle.Render("↑/↓ navigate • enter launch • → change model • esc quit")
+
+	if m.width > 0 {
+		return lipgloss.NewStyle().MaxWidth(m.width).Render(s)
+	}
 	return s
 }
 
-// renderModal renders the model picker modal.
 func (m model) renderModal() string {
 	modalStyle := lipgloss.NewStyle().
-		Border(lipgloss.RoundedBorder()).
-		BorderForeground(lipgloss.Color("245")).
-		Padding(1, 2).
-		MarginLeft(2)
+		PaddingBottom(1).
+		PaddingRight(2)
 
-	var content strings.Builder
-
-	// Title with filter
-	content.WriteString(selectorTitleStyle.Render(m.modalSelector.title))
-	content.WriteString(" ")
-	if m.modalSelector.filter == "" {
-		content.WriteString(selectorFilterStyle.Render("Type to filter..."))
-	} else {
-		content.WriteString(selectorInputStyle.Render(m.modalSelector.filter))
+	s := modalStyle.Render(m.modalSelector.renderContent())
+	if m.width > 0 {
+		return lipgloss.NewStyle().MaxWidth(m.width).Render(s)
 	}
-	content.WriteString("\n\n")
-
-	filtered := m.modalSelector.filteredItems()
-
-	if len(filtered) == 0 {
-		content.WriteString(selectorItemStyle.Render(selectorDescStyle.Render("(no matches)")))
-		content.WriteString("\n")
-	} else {
-		displayCount := min(len(filtered), maxSelectorItems)
-
-		for i := range displayCount {
-			idx := m.modalSelector.scrollOffset + i
-			if idx >= len(filtered) {
-				break
-			}
-			item := filtered[idx]
-
-			if idx == m.modalSelector.cursor {
-				content.WriteString(selectorSelectedItemStyle.Render("▸ " + item.Name))
-			} else {
-				content.WriteString(selectorItemStyle.Render(item.Name))
-			}
-
-			if item.Description != "" {
-				content.WriteString(" ")
-				content.WriteString(selectorDescStyle.Render("- " + item.Description))
-			}
-			content.WriteString("\n")
-		}
-
-		if remaining := len(filtered) - m.modalSelector.scrollOffset - displayCount; remaining > 0 {
-			content.WriteString(selectorMoreStyle.Render(fmt.Sprintf("... and %d more", remaining)))
-			content.WriteString("\n")
-		}
-	}
-
-	content.WriteString("\n")
-	content.WriteString(selectorHelpStyle.Render("↑/↓ navigate • enter select • esc cancel"))
-
-	return modalStyle.Render(content.String())
+	return s
 }
 
-// renderSignInDialog renders the sign-in dialog.
 func (m model) renderSignInDialog() string {
-	dialogStyle := lipgloss.NewStyle().
-		Border(lipgloss.RoundedBorder()).
-		BorderForeground(lipgloss.Color("245")).
-		Padding(1, 2).
-		MarginLeft(2)
-
-	spinnerFrames := []string{"⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"}
-	spinner := spinnerFrames[m.signInSpinner%len(spinnerFrames)]
-
-	var content strings.Builder
-
-	content.WriteString(selectorTitleStyle.Render("Sign in required"))
-	content.WriteString("\n\n")
-
-	content.WriteString(fmt.Sprintf("To use %s, please sign in.\n\n", selectedStyle.Render(m.signInModel)))
-
-	content.WriteString("Navigate to:\n")
-	content.WriteString(lipgloss.NewStyle().Foreground(lipgloss.Color("117")).Render("  " + m.signInURL))
-	content.WriteString("\n\n")
-
-	content.WriteString(lipgloss.NewStyle().Foreground(lipgloss.Color("241")).Render(
-		fmt.Sprintf("%s Waiting for sign in to complete...", spinner)))
-	content.WriteString("\n\n")
-
-	content.WriteString(selectorHelpStyle.Render("esc cancel"))
-
-	return dialogStyle.Render(content.String())
+	return renderSignIn(m.signInModel, m.signInURL, m.signInSpinner, m.width)
 }
 
-// Selection represents what the user selected
 type Selection int
 
 const (
@@ -680,14 +552,12 @@ const (
 	SelectionChangeIntegration // Generic change model for integration
 )
 
-// Result contains the selection and any associated data
 type Result struct {
 	Selection   Selection
 	Integration string // integration name if applicable
 	Model       string // model name if selected from modal
 }
 
-// Run starts the TUI and returns the user's selection
 func Run() (Result, error) {
 	m := initialModel()
 	p := tea.NewProgram(m)
@@ -702,14 +572,12 @@ func Run() (Result, error) {
 		return Result{Selection: SelectionNone}, fm.err
 	}
 
-	// User quit without selecting
 	if !fm.selected && !fm.changeModel {
 		return Result{Selection: SelectionNone}, nil
 	}
 
 	item := fm.items[fm.cursor]
 
-	// Handle model change request
 	if fm.changeModel {
 		if item.isRunModel {
 			return Result{
@@ -724,7 +592,6 @@ func Run() (Result, error) {
 		}, nil
 	}
 
-	// Handle selection
 	if item.isRunModel {
 		return Result{Selection: SelectionRunModel}, nil
 	}