feature: add ctrl-g to allow users to use an editor to edit their prompt

cmd/cmd.go

@@ -55,49 +55,6 @@ import (
 	"github.com/ollama/ollama/x/imagegen"
 )
 
-func init() {
-	// Override default selectors to use Bubbletea TUI instead of raw terminal I/O.
-	config.DefaultSingleSelector = func(title string, items []config.ModelItem) (string, error) {
-		tuiItems := make([]tui.SelectItem, len(items))
-		for i, item := range items {
-			tuiItems[i] = tui.SelectItem{Name: item.Name, Description: item.Description, Recommended: item.Recommended}
-		}
-		result, err := tui.SelectSingle(title, tuiItems)
-		if errors.Is(err, tui.ErrCancelled) {
-			return "", config.ErrCancelled
-		}
-		return result, err
-	}
-
-	config.DefaultMultiSelector = func(title string, items []config.ModelItem, preChecked []string) ([]string, error) {
-		tuiItems := make([]tui.SelectItem, len(items))
-		for i, item := range items {
-			tuiItems[i] = tui.SelectItem{Name: item.Name, Description: item.Description, Recommended: item.Recommended}
-		}
-		result, err := tui.SelectMultiple(title, tuiItems, preChecked)
-		if errors.Is(err, tui.ErrCancelled) {
-			return nil, config.ErrCancelled
-		}
-		return result, err
-	}
-
-	config.DefaultSignIn = func(modelName, signInURL string) (string, error) {
-		userName, err := tui.RunSignIn(modelName, signInURL)
-		if errors.Is(err, tui.ErrCancelled) {
-			return "", config.ErrCancelled
-		}
-		return userName, err
-	}
-
-	config.DefaultConfirmPrompt = func(prompt string) (bool, error) {
-		ok, err := tui.RunConfirm(prompt)
-		if errors.Is(err, tui.ErrCancelled) {
-			return false, config.ErrCancelled
-		}
-		return ok, err
-	}
-}
-
 const ConnectInstructions = "If your browser did not open, navigate to:\n    %s\n\n"
 
 // ensureThinkingSupport emits a warning if the model does not advertise thinking support
@@ -1891,15 +1848,18 @@ func runInteractiveTUI(cmd *cobra.Command) {
 		return
 	}
 
+	// errSelectionCancelled is returned when user cancels model selection
+	errSelectionCancelled := errors.New("cancelled")
+
 	// Selector adapters for tui
 	singleSelector := func(title string, items []config.ModelItem) (string, error) {
 		tuiItems := make([]tui.SelectItem, len(items))
 		for i, item := range items {
-			tuiItems[i] = tui.SelectItem{Name: item.Name, Description: item.Description, Recommended: item.Recommended}
+			tuiItems[i] = tui.SelectItem{Name: item.Name, Description: item.Description}
 		}
 		result, err := tui.SelectSingle(title, tuiItems)
 		if errors.Is(err, tui.ErrCancelled) {
-			return "", config.ErrCancelled
+			return "", errSelectionCancelled
 		}
 		return result, err
 	}
@@ -1907,11 +1867,11 @@ func runInteractiveTUI(cmd *cobra.Command) {
 	multiSelector := func(title string, items []config.ModelItem, preChecked []string) ([]string, error) {
 		tuiItems := make([]tui.SelectItem, len(items))
 		for i, item := range items {
-			tuiItems[i] = tui.SelectItem{Name: item.Name, Description: item.Description, Recommended: item.Recommended}
+			tuiItems[i] = tui.SelectItem{Name: item.Name, Description: item.Description}
 		}
 		result, err := tui.SelectMultiple(title, tuiItems, preChecked)
 		if errors.Is(err, tui.ErrCancelled) {
-			return nil, config.ErrCancelled
+			return nil, errSelectionCancelled
 		}
 		return result, err
 	}
@@ -1924,18 +1884,6 @@ func runInteractiveTUI(cmd *cobra.Command) {
 		}
 
 		runModel := func(modelName string) {
-			client, err := api.ClientFromEnvironment()
-			if err != nil {
-				fmt.Fprintf(os.Stderr, "Error: %v\n", err)
-				return
-			}
-			if err := config.ShowOrPull(cmd.Context(), client, modelName); err != nil {
-				if errors.Is(err, config.ErrCancelled) {
-					return
-				}
-				fmt.Fprintf(os.Stderr, "Error: %v\n", err)
-				return
-			}
 			_ = config.SetLastModel(modelName)
 			opts := runOptions{
 				Model:       modelName,
@@ -1957,7 +1905,7 @@ func runInteractiveTUI(cmd *cobra.Command) {
 			configuredModel := config.IntegrationModel(name)
 			if configuredModel == "" || !config.ModelExists(cmd.Context(), configuredModel) {
 				err := config.ConfigureIntegrationWithSelectors(cmd.Context(), name, singleSelector, multiSelector)
-				if errors.Is(err, config.ErrCancelled) {
+				if errors.Is(err, errSelectionCancelled) {
 					return false // Return to main menu
 				}
 				if err != nil {
@@ -1977,11 +1925,13 @@ func runInteractiveTUI(cmd *cobra.Command) {
 			return
 		case tui.SelectionRunModel:
 			_ = config.SetLastSelection("run")
-			if modelName := config.LastModel(); modelName != "" {
+			// Run last model directly if configured and still exists
+			if modelName := config.LastModel(); modelName != "" && config.ModelExists(cmd.Context(), modelName) {
 				runModel(modelName)
 			} else {
+				// No last model or model no longer exists, show picker
 				modelName, err := config.SelectModelWithSelector(cmd.Context(), singleSelector)
-				if errors.Is(err, config.ErrCancelled) {
+				if errors.Is(err, errSelectionCancelled) {
 					continue // Return to main menu
 				}
 				if err != nil {
@@ -1997,7 +1947,7 @@ func runInteractiveTUI(cmd *cobra.Command) {
 			if modelName == "" {
 				var err error
 				modelName, err = config.SelectModelWithSelector(cmd.Context(), singleSelector)
-				if errors.Is(err, config.ErrCancelled) {
+				if errors.Is(err, errSelectionCancelled) {
 					continue // Return to main menu
 				}
 				if err != nil {
@@ -2025,7 +1975,7 @@ func runInteractiveTUI(cmd *cobra.Command) {
 				}
 			} else {
 				err := config.ConfigureIntegrationWithSelectors(cmd.Context(), result.Integration, singleSelector, multiSelector)
-				if errors.Is(err, config.ErrCancelled) {
+				if errors.Is(err, errSelectionCancelled) {
 					continue // Return to main menu
 				}
 				if err != nil {
@@ -2260,7 +2210,7 @@ func NewCLI() *cobra.Command {
 		switch cmd {
 		case runCmd:
 			imagegen.AppendFlagsDocs(cmd)
-			appendEnvDocs(cmd, []envconfig.EnvVar{envVars["OLLAMA_HOST"], envVars["OLLAMA_NOHISTORY"]})
+			appendEnvDocs(cmd, []envconfig.EnvVar{envVars["OLLAMA_EDITOR"], envVars["OLLAMA_HOST"], envVars["OLLAMA_NOHISTORY"]})
 		case serveCmd:
 			appendEnvDocs(cmd, []envconfig.EnvVar{
 				envVars["OLLAMA_DEBUG"],

cmd/config/claude.go

@@ -126,7 +126,8 @@ func (c *Claude) ConfigureAliases(ctx context.Context, model string, existingAli
 	fmt.Fprintf(os.Stderr, "\n%sModel Configuration%s\n\n", ansiBold, ansiReset)
 
 	if aliases["primary"] == "" || force {
-		primary, err := DefaultSingleSelector("Select model:", items)
+		primary, err := selectPrompt("Select model:", items)
+		fmt.Fprintf(os.Stderr, "\033[3A\033[J")
 		if err != nil {
 			return nil, false, err
 		}

cmd/config/integrations.go

@@ -4,9 +4,12 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"io"
 	"maps"
+	"net/http"
 	"os"
 	"os/exec"
+	"path/filepath"
 	"runtime"
 	"slices"
 	"strings"
@@ -63,83 +66,30 @@ var integrations = map[string]Runner{
 // recommendedModels are shown when the user has no models or as suggestions.
 // Order matters: local models first, then cloud models.
 var recommendedModels = []ModelItem{
-	{Name: "kimi-k2.5:cloud", Description: "Multimodal reasoning with subagents", Recommended: true},
-	{Name: "glm-4.7:cloud", Description: "Reasoning and code generation", Recommended: true},
-	{Name: "glm-4.7-flash", Description: "Reasoning and code generation locally", Recommended: true},
-	{Name: "qwen3:8b", Description: "Efficient all-purpose assistant", Recommended: true},
-}
-
-// recommendedVRAM maps local recommended models to their approximate VRAM requirement.
-var recommendedVRAM = map[string]string{
-	"glm-4.7-flash": "~25GB",
-	"qwen3:8b":      "~11GB",
+	{Name: "glm-4.7-flash", Description: "Recommended (requires ~25GB VRAM)"},
+	{Name: "qwen3:8b", Description: "Recommended (requires ~11GB VRAM)"},
+	{Name: "glm-4.7:cloud", Description: "Recommended"},
+	{Name: "kimi-k2.5:cloud", Description: "Recommended"},
 }
 
 // integrationAliases are hidden from the interactive selector but work as CLI arguments.
 var integrationAliases = map[string]bool{
 	"clawdbot": true,
 	"moltbot":  true,
-	"pi":       true,
 }
 
-// integrationInstallHints maps integration names to install URLs.
-var integrationInstallHints = map[string]string{
-	"claude":   "https://code.claude.com/docs/en/quickstart",
-	"openclaw": "https://docs.openclaw.ai",
-	"codex":    "https://developers.openai.com/codex/cli/",
-	"droid":    "https://docs.factory.ai/cli/getting-started/quickstart",
-	"opencode": "https://opencode.ai",
+// integrationInstallURLs maps integration names to their install script URLs.
+var integrationInstallURLs = map[string]string{
+	"claude":   "https://claude.ai/install.sh",
+	"openclaw": "https://openclaw.ai/install.sh",
+	"droid":    "https://app.factory.ai/cli",
+	"opencode": "https://opencode.ai/install",
 }
 
-// hyperlink wraps text in an OSC 8 terminal hyperlink so it is cmd+clickable.
-func hyperlink(url, text string) string {
-	return fmt.Sprintf("\033]8;;%s\033\\%s\033]8;;\033\\", url, text)
-}
-
-// IntegrationInfo contains display information about a registered integration.
-type IntegrationInfo struct {
-	Name        string // registry key, e.g. "claude"
-	DisplayName string // human-readable, e.g. "Claude Code"
-	Description string // short description, e.g. "Anthropic's agentic coding tool"
-}
-
-// integrationDescriptions maps integration names to short descriptions.
-var integrationDescriptions = map[string]string{
-	"claude":   "Anthropic's coding tool with subagents",
-	"codex":    "OpenAI's open-source coding agent",
-	"openclaw": "Personal AI with 100+ skills",
-	"droid":    "Factory's coding agent across terminal and IDEs",
-	"opencode": "Anomaly's open-source coding agent",
-}
-
-// ListIntegrationInfos returns all non-alias registered integrations, sorted by name.
-func ListIntegrationInfos() []IntegrationInfo {
-	var result []IntegrationInfo
-	for name, r := range integrations {
-		if integrationAliases[name] {
-			continue
-		}
-		result = append(result, IntegrationInfo{
-			Name:        name,
-			DisplayName: r.String(),
-			Description: integrationDescriptions[name],
-		})
-	}
-	slices.SortFunc(result, func(a, b IntegrationInfo) int {
-		return strings.Compare(a.Name, b.Name)
-	})
-	return result
-}
-
-// IntegrationInstallHint returns a user-friendly install hint for the given integration,
-// or an empty string if none is available. The URL is wrapped in an OSC 8 hyperlink
-// so it is cmd+clickable in supported terminals.
-func IntegrationInstallHint(name string) string {
-	url := integrationInstallHints[name]
-	if url == "" {
-		return ""
-	}
-	return "Install from " + hyperlink(url, url)
+// CanInstallIntegration returns true if we have an install script for this integration.
+func CanInstallIntegration(name string) bool {
+	_, ok := integrationInstallURLs[name]
+	return ok
 }
 
 // IsIntegrationInstalled checks if an integration binary is installed.
@@ -171,12 +121,55 @@ func IsIntegrationInstalled(name string) bool {
 	}
 }
 
+// InstallIntegration downloads and runs the install script for an integration.
+func InstallIntegration(name string) error {
+	url, ok := integrationInstallURLs[name]
+	if !ok {
+		return fmt.Errorf("no install script available for %s", name)
+	}
+
+	// Download the install script
+	resp, err := http.Get(url)
+	if err != nil {
+		return fmt.Errorf("failed to download install script: %w", err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		return fmt.Errorf("failed to download install script: HTTP %d", resp.StatusCode)
+	}
+
+	script, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return fmt.Errorf("failed to read install script: %w", err)
+	}
+
+	// Create a temporary file for the script
+	tmpDir := os.TempDir()
+	scriptPath := filepath.Join(tmpDir, fmt.Sprintf("install-%s.sh", name))
+	if err := os.WriteFile(scriptPath, script, 0o700); err != nil {
+		return fmt.Errorf("failed to write install script: %w", err)
+	}
+	defer os.Remove(scriptPath)
+
+	// Execute the script with bash
+	cmd := exec.Command("bash", scriptPath)
+	cmd.Stdin = os.Stdin
+	cmd.Stdout = os.Stdout
+	cmd.Stderr = os.Stderr
+
+	if err := cmd.Run(); err != nil {
+		return fmt.Errorf("install script failed: %w", err)
+	}
+
+	return nil
+}
+
 // SelectModel lets the user select a model to run.
 // ModelItem represents a model for selection.
 type ModelItem struct {
 	Name        string
 	Description string
-	Recommended bool
 }
 
 // SingleSelector is a function type for single item selection.
@@ -214,6 +207,27 @@ func SelectModelWithSelector(ctx context.Context, selector SingleSelector) (stri
 		return "", fmt.Errorf("no models available, run 'ollama pull <model>' first")
 	}
 
+	// Sort with last model first, then existing models, then recommendations
+	slices.SortStableFunc(items, func(a, b ModelItem) int {
+		aIsLast := a.Name == lastModel
+		bIsLast := b.Name == lastModel
+		if aIsLast != bIsLast {
+			if aIsLast {
+				return -1
+			}
+			return 1
+		}
+		aExists := existingModels[a.Name]
+		bExists := existingModels[b.Name]
+		if aExists != bExists {
+			if aExists {
+				return -1
+			}
+			return 1
+		}
+		return strings.Compare(strings.ToLower(a.Name), strings.ToLower(b.Name))
+	})
+
 	selected, err := selector("Select model to run:", items)
 	if err != nil {
 		return "", err
@@ -295,30 +309,32 @@ func SelectModelWithSelector(ctx context.Context, selector SingleSelector) (stri
 }
 
 func SelectModel(ctx context.Context) (string, error) {
-	return SelectModelWithSelector(ctx, DefaultSingleSelector)
+	return SelectModelWithSelector(ctx, defaultSingleSelector)
 }
 
-// DefaultSingleSelector is the default single-select implementation.
-var DefaultSingleSelector SingleSelector
+func defaultSingleSelector(title string, items []ModelItem) (string, error) {
+	selectItems := make([]selectItem, len(items))
+	for i, item := range items {
+		selectItems[i] = selectItem(item)
+	}
+	return selectPrompt(title, selectItems)
+}
 
-// DefaultMultiSelector is the default multi-select implementation.
-var DefaultMultiSelector MultiSelector
-
-// DefaultSignIn provides a TUI-based sign-in flow.
-// When set, ensureAuth uses it instead of plain text prompts.
-// Returns the signed-in username or an error.
-var DefaultSignIn func(modelName, signInURL string) (string, error)
+func defaultMultiSelector(title string, items []ModelItem, preChecked []string) ([]string, error) {
+	selectItems := make([]selectItem, len(items))
+	for i, item := range items {
+		selectItems[i] = selectItem(item)
+	}
+	return multiSelectPrompt(title, selectItems, preChecked)
+}
 
 func selectIntegration() (string, error) {
-	if DefaultSingleSelector == nil {
-		return "", fmt.Errorf("no selector configured")
-	}
 	if len(integrations) == 0 {
 		return "", fmt.Errorf("no integrations available")
 	}
 
 	names := slices.Sorted(maps.Keys(integrations))
-	var items []ModelItem
+	var items []selectItem
 	for _, name := range names {
 		if integrationAliases[name] {
 			continue
@@ -328,10 +344,10 @@ func selectIntegration() (string, error) {
 		if conn, err := loadIntegration(name); err == nil && len(conn.Models) > 0 {
 			description = fmt.Sprintf("%s (%s)", r.String(), conn.Models[0])
 		}
-		items = append(items, ModelItem{Name: name, Description: description})
+		items = append(items, selectItem{Name: name, Description: description})
 	}
 
-	return DefaultSingleSelector("Select integration:", items)
+	return selectPrompt("Select integration:", items)
 }
 
 // selectModelsWithSelectors lets the user select models for an integration using provided selectors.
@@ -432,9 +448,8 @@ func pullIfNeeded(ctx context.Context, client *api.Client, existingModels map[st
 	return nil
 }
 
-// TODO(parthsareen): pull this out to tui package
-// ShowOrPull checks if a model exists via client.Show and offers to pull it if not found.
-func ShowOrPull(ctx context.Context, client *api.Client, model string) error {
+// showOrPull checks if a model exists via client.Show and offers to pull it if not found.
+func showOrPull(ctx context.Context, client *api.Client, model string) error {
 	if _, err := client.Show(ctx, &api.ShowRequest{Model: model}); err == nil {
 		return nil
 	}
@@ -447,7 +462,7 @@ func ShowOrPull(ctx context.Context, client *api.Client, model string) error {
 	return pullModel(ctx, client, model)
 }
 
-func listModels(ctx context.Context) ([]ModelItem, map[string]bool, map[string]bool, *api.Client, error) {
+func listModels(ctx context.Context) ([]selectItem, map[string]bool, map[string]bool, *api.Client, error) {
 	client, err := api.ClientFromEnvironment()
 	if err != nil {
 		return nil, nil, nil, nil, err
@@ -466,24 +481,18 @@ func listModels(ctx context.Context) ([]ModelItem, map[string]bool, map[string]b
 		})
 	}
 
-	items, _, existingModels, cloudModels := buildModelList(existing, nil, "")
+	modelItems, _, existingModels, cloudModels := buildModelList(existing, nil, "")
 
-	if len(items) == 0 {
+	if len(modelItems) == 0 {
 		return nil, nil, nil, nil, fmt.Errorf("no models available, run 'ollama pull <model>' first")
 	}
 
-	return items, existingModels, cloudModels, client, nil
-}
-
-func OpenBrowser(url string) {
-	switch runtime.GOOS {
-	case "darwin":
-		_ = exec.Command("open", url).Start()
-	case "linux":
-		_ = exec.Command("xdg-open", url).Start()
-	case "windows":
-		_ = exec.Command("rundll32", "url.dll,FileProtocolHandler", url).Start()
+	items := make([]selectItem, len(modelItems))
+	for i, mi := range modelItems {
+		items[i] = selectItem(mi)
 	}
+
+	return items, existingModels, cloudModels, client, nil
 }
 
 func ensureAuth(ctx context.Context, client *api.Client, cloudModels map[string]bool, selected []string) error {
@@ -508,16 +517,6 @@ func ensureAuth(ctx context.Context, client *api.Client, cloudModels map[string]
 	}
 
 	modelList := strings.Join(selectedCloudModels, ", ")
-
-	if DefaultSignIn != nil {
-		_, err := DefaultSignIn(modelList, aErr.SigninURL)
-		if err != nil {
-			return fmt.Errorf("%s requires sign in", modelList)
-		}
-		return nil
-	}
-
-	// Fallback: plain text sign-in flow
 	yes, err := confirmPrompt(fmt.Sprintf("sign in to use %s?", modelList))
 	if err != nil || !yes {
 		return fmt.Errorf("%s requires sign in", modelList)
@@ -525,7 +524,14 @@ func ensureAuth(ctx context.Context, client *api.Client, cloudModels map[string]
 
 	fmt.Fprintf(os.Stderr, "\nTo sign in, navigate to:\n    %s\n\n", aErr.SigninURL)
 
-	OpenBrowser(aErr.SigninURL)
+	switch runtime.GOOS {
+	case "darwin":
+		_ = exec.Command("open", aErr.SigninURL).Start()
+	case "linux":
+		_ = exec.Command("xdg-open", aErr.SigninURL).Start()
+	case "windows":
+		_ = exec.Command("rundll32", "url.dll,FileProtocolHandler", aErr.SigninURL).Start()
+	}
 
 	spinnerFrames := []string{"|", "/", "-", "\\"}
 	frame := 0
@@ -558,7 +564,7 @@ func ensureAuth(ctx context.Context, client *api.Client, cloudModels map[string]
 
 // selectModels lets the user select models for an integration using default selectors.
 func selectModels(ctx context.Context, name, current string) ([]string, error) {
-	return selectModelsWithSelectors(ctx, name, current, DefaultSingleSelector, DefaultMultiSelector)
+	return selectModelsWithSelectors(ctx, name, current, defaultSingleSelector, defaultMultiSelector)
 }
 
 func runIntegration(name, modelName string, args []string) error {
@@ -601,15 +607,8 @@ func LaunchIntegration(name string) error {
 	}
 
 	// Try to use saved config
-	if ic, err := loadIntegration(name); err == nil && len(ic.Models) > 0 {
-		client, err := api.ClientFromEnvironment()
-		if err != nil {
-			return err
-		}
-		if err := ShowOrPull(context.Background(), client, ic.Models[0]); err != nil {
-			return err
-		}
-		return runIntegration(name, ic.Models[0], nil)
+	if config, err := loadIntegration(name); err == nil && len(config.Models) > 0 {
+		return runIntegration(name, config.Models[0], nil)
 	}
 
 	// No saved config - prompt user to run setup
@@ -618,13 +617,6 @@ func LaunchIntegration(name string) error {
 
 // LaunchIntegrationWithModel launches the named integration with the specified model.
 func LaunchIntegrationWithModel(name, modelName string) error {
-	client, err := api.ClientFromEnvironment()
-	if err != nil {
-		return err
-	}
-	if err := ShowOrPull(context.Background(), client, modelName); err != nil {
-		return err
-	}
 	return runIntegration(name, modelName, nil)
 }
 
@@ -656,7 +648,7 @@ func ConfigureIntegrationWithSelectors(ctx context.Context, name string, single
 
 	models, err := selectModelsWithSelectors(ctx, name, "", single, multi)
 	if errors.Is(err, errCancelled) {
-		return errCancelled
+		return nil
 	}
 	if err != nil {
 		return err
@@ -696,7 +688,7 @@ func ConfigureIntegrationWithSelectors(ctx context.Context, name string, single
 
 // ConfigureIntegration allows the user to select/change the model for an integration.
 func ConfigureIntegration(ctx context.Context, name string) error {
-	return ConfigureIntegrationWithSelectors(ctx, name, DefaultSingleSelector, DefaultMultiSelector)
+	return ConfigureIntegrationWithSelectors(ctx, name, defaultSingleSelector, defaultMultiSelector)
 }
 
 // LaunchCmd returns the cobra command for launching integrations.
@@ -729,7 +721,7 @@ Examples:
 		Args:    cobra.ArbitraryArgs,
 		PreRunE: checkServerHeartbeat,
 		RunE: func(cmd *cobra.Command, args []string) error {
-			// No args and no flags - show the full TUI (same as bare 'ollama')
+			// No args - run the main TUI (same as 'ollama')
 			if len(args) == 0 && modelFlag == "" && !configFlag {
 				runTUI(cmd)
 				return nil
@@ -784,7 +776,7 @@ Examples:
 
 				// Validate --model flag if provided
 				if modelFlag != "" {
-					if err := ShowOrPull(cmd.Context(), client, modelFlag); err != nil {
+					if err := showOrPull(cmd.Context(), client, modelFlag); err != nil {
 						if errors.Is(err, errCancelled) {
 							return nil
 						}
@@ -816,7 +808,7 @@ Examples:
 				if model != "" && modelFlag == "" {
 					if _, err := client.Show(cmd.Context(), &api.ShowRequest{Model: model}); err != nil {
 						fmt.Fprintf(os.Stderr, "%sConfigured model %q not found%s\n\n", ansiGray, model, ansiReset)
-						if err := ShowOrPull(cmd.Context(), client, model); err != nil {
+						if err := showOrPull(cmd.Context(), client, model); err != nil {
 							model = ""
 						}
 					}
@@ -866,7 +858,7 @@ Examples:
 				if err != nil {
 					return err
 				}
-				if err := ShowOrPull(cmd.Context(), client, modelFlag); err != nil {
+				if err := showOrPull(cmd.Context(), client, modelFlag); err != nil {
 					if errors.Is(err, errCancelled) {
 						return nil
 					}
@@ -961,10 +953,8 @@ func buildModelList(existing []modelInfo, preChecked []string, current string) (
 	recommended := make(map[string]bool)
 	var hasLocalModel, hasCloudModel bool
 
-	recDesc := make(map[string]string)
 	for _, rec := range recommendedModels {
 		recommended[rec.Name] = true
-		recDesc[rec.Name] = rec.Description
 	}
 
 	for _, m := range existing {
@@ -977,7 +967,10 @@ func buildModelList(existing []modelInfo, preChecked []string, current string) (
 		}
 		displayName := strings.TrimSuffix(m.Name, ":latest")
 		existingModels[displayName] = true
-		item := ModelItem{Name: displayName, Recommended: recommended[displayName], Description: recDesc[displayName]}
+		item := ModelItem{Name: displayName}
+		if recommended[displayName] {
+			item.Description = "recommended"
+		}
 		items = append(items, item)
 	}
 
@@ -1014,76 +1007,31 @@ func buildModelList(existing []modelInfo, preChecked []string, current string) (
 	for i := range items {
 		if !existingModels[items[i].Name] {
 			notInstalled[items[i].Name] = true
-			var parts []string
 			if items[i].Description != "" {
-				parts = append(parts, items[i].Description)
+				items[i].Description += ", install?"
+			} else {
+				items[i].Description = "install?"
 			}
-			if vram := recommendedVRAM[items[i].Name]; vram != "" {
-				parts = append(parts, vram)
-			}
-			parts = append(parts, "install?")
-			items[i].Description = strings.Join(parts, ", ")
 		}
 	}
 
-	// Build a recommended rank map to preserve ordering within tiers.
-	recRank := make(map[string]int)
-	for i, rec := range recommendedModels {
-		recRank[rec.Name] = i + 1 // 1-indexed; 0 means not recommended
-	}
-
-	onlyLocal := hasLocalModel && !hasCloudModel
-
 	if hasLocalModel || hasCloudModel {
 		slices.SortStableFunc(items, func(a, b ModelItem) int {
 			ac, bc := checked[a.Name], checked[b.Name]
 			aNew, bNew := notInstalled[a.Name], notInstalled[b.Name]
-			aRec, bRec := recRank[a.Name] > 0, recRank[b.Name] > 0
-			aCloud, bCloud := cloudModels[a.Name], cloudModels[b.Name]
 
-			// Checked/pre-selected always first
 			if ac != bc {
 				if ac {
 					return -1
 				}
 				return 1
 			}
-
-			// Recommended above non-recommended
-			if aRec != bRec {
-				if aRec {
-					return -1
-				}
-				return 1
-			}
-
-			// Both recommended
-			if aRec && bRec {
-				if aCloud != bCloud {
-					if onlyLocal {
-						// Local before cloud when only local installed
-						if aCloud {
-							return 1
-						}
-						return -1
-					}
-					// Cloud before local in mixed case
-					if aCloud {
-						return -1
-					}
-					return 1
-				}
-				return recRank[a.Name] - recRank[b.Name]
-			}
-
-			// Both non-recommended: installed before not-installed
-			if aNew != bNew {
+			if !ac && !bc && aNew != bNew {
 				if aNew {
 					return 1
 				}
 				return -1
 			}
-
 			return strings.Compare(strings.ToLower(a.Name), strings.ToLower(b.Name))
 		})
 	}
@@ -1129,6 +1077,27 @@ func GetModelItems(ctx context.Context) ([]ModelItem, map[string]bool) {
 
 	items, _, existingModels, _ := buildModelList(existing, preChecked, lastModel)
 
+	// Sort with last model first, then existing models, then recommendations
+	slices.SortStableFunc(items, func(a, b ModelItem) int {
+		aIsLast := a.Name == lastModel
+		bIsLast := b.Name == lastModel
+		if aIsLast != bIsLast {
+			if aIsLast {
+				return -1
+			}
+			return 1
+		}
+		aExists := existingModels[a.Name]
+		bExists := existingModels[b.Name]
+		if aExists != bExists {
+			if aExists {
+				return -1
+			}
+			return 1
+		}
+		return strings.Compare(strings.ToLower(a.Name), strings.ToLower(b.Name))
+	})
+
 	return items, existingModels
 }
 

cmd/config/integrations_test.go

@@ -94,7 +94,9 @@ func TestLaunchCmd(t *testing.T) {
 	mockCheck := func(cmd *cobra.Command, args []string) error {
 		return nil
 	}
+	// Mock TUI function (not called in these tests)
 	mockTUI := func(cmd *cobra.Command) {}
+
 	cmd := LaunchCmd(mockCheck, mockTUI)
 
 	t.Run("command structure", func(t *testing.T) {
@@ -394,7 +396,7 @@ func names(items []ModelItem) []string {
 func TestBuildModelList_NoExistingModels(t *testing.T) {
 	items, _, _, _ := buildModelList(nil, nil, "")
 
-	want := []string{"kimi-k2.5:cloud", "glm-4.7:cloud", "glm-4.7-flash", "qwen3:8b"}
+	want := []string{"glm-4.7-flash", "qwen3:8b", "glm-4.7:cloud", "kimi-k2.5:cloud"}
 	if diff := cmp.Diff(want, names(items)); diff != "" {
 		t.Errorf("with no existing models, items should be recommended in order (-want +got):\n%s", diff)
 	}
@@ -415,10 +417,9 @@ func TestBuildModelList_OnlyLocalModels_CloudRecsAtBottom(t *testing.T) {
 	items, _, _, _ := buildModelList(existing, nil, "")
 	got := names(items)
 
-	// Recommended pinned at top (local recs first, then cloud recs when only-local), then installed non-recs
-	want := []string{"glm-4.7-flash", "qwen3:8b", "kimi-k2.5:cloud", "glm-4.7:cloud", "llama3.2", "qwen2.5"}
+	want := []string{"llama3.2", "qwen2.5", "glm-4.7-flash", "glm-4.7:cloud", "kimi-k2.5:cloud", "qwen3:8b"}
 	if diff := cmp.Diff(want, got); diff != "" {
-		t.Errorf("recs pinned at top, local recs before cloud recs (-want +got):\n%s", diff)
+		t.Errorf("cloud recs should be at bottom (-want +got):\n%s", diff)
 	}
 }
 
@@ -431,10 +432,9 @@ func TestBuildModelList_BothCloudAndLocal_RegularSort(t *testing.T) {
 	items, _, _, _ := buildModelList(existing, nil, "")
 	got := names(items)
 
-	// All recs pinned at top (cloud before local in mixed case), then non-recs
-	want := []string{"kimi-k2.5:cloud", "glm-4.7:cloud", "glm-4.7-flash", "qwen3:8b", "llama3.2"}
+	want := []string{"glm-4.7:cloud", "llama3.2", "glm-4.7-flash", "kimi-k2.5:cloud", "qwen3:8b"}
 	if diff := cmp.Diff(want, got); diff != "" {
-		t.Errorf("recs pinned at top, cloud recs first in mixed case (-want +got):\n%s", diff)
+		t.Errorf("mixed models should be alphabetical (-want +got):\n%s", diff)
 	}
 }
 
@@ -485,10 +485,9 @@ func TestBuildModelList_ExistingCloudModelsNotPushedToBottom(t *testing.T) {
 
 	// glm-4.7-flash and glm-4.7:cloud are installed so they sort normally;
 	// kimi-k2.5:cloud and qwen3:8b are not installed so they go to the bottom
-	// All recs: cloud first in mixed case, then local, in rec order within each
-	want := []string{"kimi-k2.5:cloud", "glm-4.7:cloud", "glm-4.7-flash", "qwen3:8b"}
+	want := []string{"glm-4.7-flash", "glm-4.7:cloud", "kimi-k2.5:cloud", "qwen3:8b"}
 	if diff := cmp.Diff(want, got); diff != "" {
-		t.Errorf("all recs, cloud first in mixed case (-want +got):\n%s", diff)
+		t.Errorf("existing cloud models should sort normally (-want +got):\n%s", diff)
 	}
 }
 
@@ -503,10 +502,9 @@ func TestBuildModelList_HasRecommendedCloudModel_OnlyNonInstalledAtBottom(t *tes
 
 	// kimi-k2.5:cloud is installed so it sorts normally;
 	// the rest of the recommendations are not installed so they go to the bottom
-	// All recs pinned at top (cloud first in mixed case), then non-recs
-	want := []string{"kimi-k2.5:cloud", "glm-4.7:cloud", "glm-4.7-flash", "qwen3:8b", "llama3.2"}
+	want := []string{"kimi-k2.5:cloud", "llama3.2", "glm-4.7-flash", "glm-4.7:cloud", "qwen3:8b"}
 	if diff := cmp.Diff(want, got); diff != "" {
-		t.Errorf("recs pinned at top, cloud first in mixed case (-want +got):\n%s", diff)
+		t.Errorf("only non-installed models should be at bottom (-want +got):\n%s", diff)
 	}
 
 	for _, item := range items {
@@ -580,101 +578,6 @@ func TestBuildModelList_ReturnsExistingAndCloudMaps(t *testing.T) {
 	}
 }
 
-func TestBuildModelList_RecommendedFieldSet(t *testing.T) {
-	existing := []modelInfo{
-		{Name: "glm-4.7-flash", Remote: false},
-		{Name: "llama3.2:latest", Remote: false},
-	}
-
-	items, _, _, _ := buildModelList(existing, nil, "")
-
-	for _, item := range items {
-		switch item.Name {
-		case "glm-4.7-flash", "qwen3:8b", "glm-4.7:cloud", "kimi-k2.5:cloud":
-			if !item.Recommended {
-				t.Errorf("%q should have Recommended=true", item.Name)
-			}
-		case "llama3.2":
-			if item.Recommended {
-				t.Errorf("%q should have Recommended=false", item.Name)
-			}
-		}
-	}
-}
-
-func TestBuildModelList_MixedCase_CloudRecsFirst(t *testing.T) {
-	existing := []modelInfo{
-		{Name: "llama3.2:latest", Remote: false},
-		{Name: "glm-4.7:cloud", Remote: true},
-	}
-
-	items, _, _, _ := buildModelList(existing, nil, "")
-	got := names(items)
-
-	// Cloud recs should sort before local recs in mixed case
-	cloudIdx := slices.Index(got, "glm-4.7:cloud")
-	localIdx := slices.Index(got, "glm-4.7-flash")
-	if cloudIdx > localIdx {
-		t.Errorf("cloud recs should be before local recs in mixed case, got %v", got)
-	}
-}
-
-func TestBuildModelList_OnlyLocal_LocalRecsFirst(t *testing.T) {
-	existing := []modelInfo{
-		{Name: "llama3.2:latest", Remote: false},
-	}
-
-	items, _, _, _ := buildModelList(existing, nil, "")
-	got := names(items)
-
-	// Local recs should sort before cloud recs in only-local case
-	localIdx := slices.Index(got, "glm-4.7-flash")
-	cloudIdx := slices.Index(got, "glm-4.7:cloud")
-	if localIdx > cloudIdx {
-		t.Errorf("local recs should be before cloud recs in only-local case, got %v", got)
-	}
-}
-
-func TestBuildModelList_RecsAboveNonRecs(t *testing.T) {
-	existing := []modelInfo{
-		{Name: "llama3.2:latest", Remote: false},
-		{Name: "custom-model", Remote: false},
-	}
-
-	items, _, _, _ := buildModelList(existing, nil, "")
-	got := names(items)
-
-	// All recommended models should appear before non-recommended installed models
-	lastRecIdx := -1
-	firstNonRecIdx := len(got)
-	for i, name := range got {
-		isRec := name == "glm-4.7-flash" || name == "qwen3:8b" || name == "glm-4.7:cloud" || name == "kimi-k2.5:cloud"
-		if isRec && i > lastRecIdx {
-			lastRecIdx = i
-		}
-		if !isRec && i < firstNonRecIdx {
-			firstNonRecIdx = i
-		}
-	}
-	if lastRecIdx > firstNonRecIdx {
-		t.Errorf("all recs should be above non-recs, got %v", got)
-	}
-}
-
-func TestBuildModelList_CheckedBeforeRecs(t *testing.T) {
-	existing := []modelInfo{
-		{Name: "llama3.2:latest", Remote: false},
-		{Name: "glm-4.7:cloud", Remote: true},
-	}
-
-	items, _, _, _ := buildModelList(existing, []string{"llama3.2"}, "")
-	got := names(items)
-
-	if got[0] != "llama3.2" {
-		t.Errorf("checked model should be first even before recs, got %v", got)
-	}
-}
-
 func TestEditorIntegration_SavedConfigSkipsSelection(t *testing.T) {
 	tmpDir := t.TempDir()
 	setTestHome(t, tmpDir)
@@ -727,7 +630,7 @@ func TestShowOrPull_ModelExists(t *testing.T) {
 	u, _ := url.Parse(srv.URL)
 	client := api.NewClient(u, srv.Client())
 
-	err := ShowOrPull(context.Background(), client, "test-model")
+	err := showOrPull(context.Background(), client, "test-model")
 	if err != nil {
 		t.Errorf("showOrPull should return nil when model exists, got: %v", err)
 	}
@@ -744,7 +647,7 @@ func TestShowOrPull_ModelNotFound_NoTerminal(t *testing.T) {
 	client := api.NewClient(u, srv.Client())
 
 	// confirmPrompt will fail in test (no terminal), so showOrPull should return an error
-	err := ShowOrPull(context.Background(), client, "missing-model")
+	err := showOrPull(context.Background(), client, "missing-model")
 	if err == nil {
 		t.Error("showOrPull should return error when model not found and no terminal available")
 	}
@@ -769,104 +672,12 @@ func TestShowOrPull_ShowCalledWithCorrectModel(t *testing.T) {
 	u, _ := url.Parse(srv.URL)
 	client := api.NewClient(u, srv.Client())
 
-	_ = ShowOrPull(context.Background(), client, "qwen3:8b")
+	_ = showOrPull(context.Background(), client, "qwen3:8b")
 	if receivedModel != "qwen3:8b" {
 		t.Errorf("expected Show to be called with %q, got %q", "qwen3:8b", receivedModel)
 	}
 }
 
-func TestShowOrPull_ModelNotFound_ConfirmYes_Pulls(t *testing.T) {
-	// Set up hook so confirmPrompt doesn't need a terminal
-	oldHook := DefaultConfirmPrompt
-	DefaultConfirmPrompt = func(prompt string) (bool, error) {
-		if !strings.Contains(prompt, "missing-model") {
-			t.Errorf("expected prompt to contain model name, got %q", prompt)
-		}
-		return true, nil
-	}
-	defer func() { DefaultConfirmPrompt = oldHook }()
-
-	var pullCalled bool
-	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch r.URL.Path {
-		case "/api/show":
-			w.WriteHeader(http.StatusNotFound)
-			fmt.Fprintf(w, `{"error":"model not found"}`)
-		case "/api/pull":
-			pullCalled = true
-			w.WriteHeader(http.StatusOK)
-			fmt.Fprintf(w, `{"status":"success"}`)
-		default:
-			w.WriteHeader(http.StatusNotFound)
-		}
-	}))
-	defer srv.Close()
-
-	u, _ := url.Parse(srv.URL)
-	client := api.NewClient(u, srv.Client())
-
-	err := ShowOrPull(context.Background(), client, "missing-model")
-	if err != nil {
-		t.Errorf("ShowOrPull should succeed after pull, got: %v", err)
-	}
-	if !pullCalled {
-		t.Error("expected pull to be called when user confirms download")
-	}
-}
-
-func TestShowOrPull_ModelNotFound_ConfirmNo_Cancelled(t *testing.T) {
-	oldHook := DefaultConfirmPrompt
-	DefaultConfirmPrompt = func(prompt string) (bool, error) {
-		return false, ErrCancelled
-	}
-	defer func() { DefaultConfirmPrompt = oldHook }()
-
-	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch r.URL.Path {
-		case "/api/show":
-			w.WriteHeader(http.StatusNotFound)
-			fmt.Fprintf(w, `{"error":"model not found"}`)
-		case "/api/pull":
-			t.Error("pull should not be called when user declines")
-		default:
-			w.WriteHeader(http.StatusNotFound)
-		}
-	}))
-	defer srv.Close()
-
-	u, _ := url.Parse(srv.URL)
-	client := api.NewClient(u, srv.Client())
-
-	err := ShowOrPull(context.Background(), client, "missing-model")
-	if err == nil {
-		t.Error("ShowOrPull should return error when user declines")
-	}
-}
-
-func TestConfirmPrompt_DelegatesToHook(t *testing.T) {
-	oldHook := DefaultConfirmPrompt
-	var hookCalled bool
-	DefaultConfirmPrompt = func(prompt string) (bool, error) {
-		hookCalled = true
-		if prompt != "test prompt?" {
-			t.Errorf("expected prompt %q, got %q", "test prompt?", prompt)
-		}
-		return true, nil
-	}
-	defer func() { DefaultConfirmPrompt = oldHook }()
-
-	ok, err := confirmPrompt("test prompt?")
-	if err != nil {
-		t.Errorf("unexpected error: %v", err)
-	}
-	if !ok {
-		t.Error("expected true from hook")
-	}
-	if !hookCalled {
-		t.Error("expected DefaultConfirmPrompt hook to be called")
-	}
-}
-
 func TestEnsureAuth_NoCloudModels(t *testing.T) {
 	// ensureAuth should be a no-op when no cloud models are selected
 	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
@@ -937,230 +748,3 @@ func TestEnsureAuth_SkipsWhenNoCloudSelected(t *testing.T) {
 		t.Error("whoami should not be called when no cloud models are selected")
 	}
 }
-
-func TestHyperlink(t *testing.T) {
-	tests := []struct {
-		name     string
-		url      string
-		text     string
-		wantURL  string
-		wantText string
-	}{
-		{
-			name:     "basic link",
-			url:      "https://example.com",
-			text:     "click here",
-			wantURL:  "https://example.com",
-			wantText: "click here",
-		},
-		{
-			name:     "url with path",
-			url:      "https://example.com/docs/install",
-			text:     "install docs",
-			wantURL:  "https://example.com/docs/install",
-			wantText: "install docs",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			got := hyperlink(tt.url, tt.text)
-
-			// Should contain OSC 8 escape sequences
-			if !strings.Contains(got, "\033]8;;") {
-				t.Error("should contain OSC 8 open sequence")
-			}
-			if !strings.Contains(got, tt.wantURL) {
-				t.Errorf("should contain URL %q", tt.wantURL)
-			}
-			if !strings.Contains(got, tt.wantText) {
-				t.Errorf("should contain text %q", tt.wantText)
-			}
-
-			// Should have closing OSC 8 sequence
-			wantSuffix := "\033]8;;\033\\"
-			if !strings.HasSuffix(got, wantSuffix) {
-				t.Error("should end with OSC 8 close sequence")
-			}
-		})
-	}
-}
-
-func TestIntegrationInstallHint(t *testing.T) {
-	tests := []struct {
-		name      string
-		input     string
-		wantEmpty bool
-		wantURL   string
-	}{
-		{
-			name:    "claude has hint",
-			input:   "claude",
-			wantURL: "https://code.claude.com/docs/en/quickstart",
-		},
-		{
-			name:    "codex has hint",
-			input:   "codex",
-			wantURL: "https://developers.openai.com/codex/cli/",
-		},
-		{
-			name:    "openclaw has hint",
-			input:   "openclaw",
-			wantURL: "https://docs.openclaw.ai",
-		},
-		{
-			name:      "unknown has no hint",
-			input:     "unknown",
-			wantEmpty: true,
-		},
-		{
-			name:      "empty name has no hint",
-			input:     "",
-			wantEmpty: true,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			got := IntegrationInstallHint(tt.input)
-			if tt.wantEmpty {
-				if got != "" {
-					t.Errorf("expected empty hint, got %q", got)
-				}
-				return
-			}
-			if !strings.Contains(got, "Install from") {
-				t.Errorf("hint should start with 'Install from', got %q", got)
-			}
-			if !strings.Contains(got, tt.wantURL) {
-				t.Errorf("hint should contain URL %q, got %q", tt.wantURL, got)
-			}
-			// Should be a clickable hyperlink
-			if !strings.Contains(got, "\033]8;;") {
-				t.Error("hint URL should be wrapped in OSC 8 hyperlink")
-			}
-		})
-	}
-}
-
-func TestListIntegrationInfos(t *testing.T) {
-	infos := ListIntegrationInfos()
-
-	t.Run("excludes aliases", func(t *testing.T) {
-		for _, info := range infos {
-			if integrationAliases[info.Name] {
-				t.Errorf("alias %q should not appear in ListIntegrationInfos", info.Name)
-			}
-		}
-	})
-
-	t.Run("sorted by name", func(t *testing.T) {
-		for i := 1; i < len(infos); i++ {
-			if infos[i-1].Name >= infos[i].Name {
-				t.Errorf("not sorted: %q >= %q", infos[i-1].Name, infos[i].Name)
-			}
-		}
-	})
-
-	t.Run("all fields populated", func(t *testing.T) {
-		for _, info := range infos {
-			if info.Name == "" {
-				t.Error("Name should not be empty")
-			}
-			if info.DisplayName == "" {
-				t.Errorf("DisplayName for %q should not be empty", info.Name)
-			}
-		}
-	})
-
-	t.Run("includes known integrations", func(t *testing.T) {
-		known := map[string]bool{"claude": false, "codex": false, "opencode": false}
-		for _, info := range infos {
-			if _, ok := known[info.Name]; ok {
-				known[info.Name] = true
-			}
-		}
-		for name, found := range known {
-			if !found {
-				t.Errorf("expected %q in ListIntegrationInfos", name)
-			}
-		}
-	})
-}
-
-func TestBuildModelList_Descriptions(t *testing.T) {
-	t.Run("installed recommended has base description", func(t *testing.T) {
-		existing := []modelInfo{
-			{Name: "qwen3:8b", Remote: false},
-		}
-		items, _, _, _ := buildModelList(existing, nil, "")
-
-		for _, item := range items {
-			if item.Name == "qwen3:8b" {
-				if strings.HasSuffix(item.Description, "install?") {
-					t.Errorf("installed model should not have 'install?' suffix, got %q", item.Description)
-				}
-				if item.Description == "" {
-					t.Error("installed recommended model should have a description")
-				}
-				return
-			}
-		}
-		t.Error("qwen3:8b not found in items")
-	})
-
-	t.Run("not-installed local rec has VRAM in description", func(t *testing.T) {
-		items, _, _, _ := buildModelList(nil, nil, "")
-
-		for _, item := range items {
-			if item.Name == "qwen3:8b" {
-				if !strings.Contains(item.Description, "~11GB") {
-					t.Errorf("not-installed qwen3:8b should show VRAM hint, got %q", item.Description)
-				}
-				return
-			}
-		}
-		t.Error("qwen3:8b not found in items")
-	})
-
-	t.Run("installed local rec omits VRAM", func(t *testing.T) {
-		existing := []modelInfo{
-			{Name: "qwen3:8b", Remote: false},
-		}
-		items, _, _, _ := buildModelList(existing, nil, "")
-
-		for _, item := range items {
-			if item.Name == "qwen3:8b" {
-				if strings.Contains(item.Description, "~11GB") {
-					t.Errorf("installed qwen3:8b should not show VRAM hint, got %q", item.Description)
-				}
-				return
-			}
-		}
-		t.Error("qwen3:8b not found in items")
-	})
-}
-
-func TestLaunchIntegration_UnknownIntegration(t *testing.T) {
-	err := LaunchIntegration("nonexistent-integration")
-	if err == nil {
-		t.Fatal("expected error for unknown integration")
-	}
-	if !strings.Contains(err.Error(), "unknown integration") {
-		t.Errorf("error should mention 'unknown integration', got: %v", err)
-	}
-}
-
-func TestLaunchIntegration_NotConfigured(t *testing.T) {
-	tmpDir := t.TempDir()
-	setTestHome(t, tmpDir)
-
-	// Claude is a known integration but not configured in temp dir
-	err := LaunchIntegration("claude")
-	if err == nil {
-		t.Fatal("expected error when integration is not configured")
-	}
-	if !strings.Contains(err.Error(), "not configured") {
-		t.Errorf("error should mention 'not configured', got: %v", err)
-	}
-}

cmd/config/selector.go

@@ -3,34 +3,475 @@ package config
 import (
 	"errors"
 	"fmt"
+	"io"
 	"os"
+	"strings"
 
 	"golang.org/x/term"
 )
 
 // ANSI escape sequences for terminal formatting.
 const (
-	ansiBold  = "\033[1m"
-	ansiReset = "\033[0m"
-	ansiGray  = "\033[37m"
-	ansiGreen = "\033[32m"
+	ansiHideCursor = "\033[?25l"
+	ansiShowCursor = "\033[?25h"
+	ansiBold       = "\033[1m"
+	ansiReset      = "\033[0m"
+	ansiGray       = "\033[37m"
+	ansiGreen      = "\033[32m"
+	ansiClearDown  = "\033[J"
 )
 
-// ErrCancelled is returned when the user cancels a selection.
-var ErrCancelled = errors.New("cancelled")
+const maxDisplayedItems = 10
 
-// errCancelled is kept as an alias for backward compatibility within the package.
-var errCancelled = ErrCancelled
+var errCancelled = errors.New("cancelled")
 
-// DefaultConfirmPrompt provides a TUI-based confirmation prompt.
-// When set, confirmPrompt delegates to it instead of using raw terminal I/O.
-var DefaultConfirmPrompt func(prompt string) (bool, error)
+type selectItem struct {
+	Name        string
+	Description string
+}
 
-func confirmPrompt(prompt string) (bool, error) {
-	if DefaultConfirmPrompt != nil {
-		return DefaultConfirmPrompt(prompt)
+type inputEvent int
+
+const (
+	eventNone inputEvent = iota
+	eventEnter
+	eventEscape
+	eventUp
+	eventDown
+	eventTab
+	eventBackspace
+	eventChar
+)
+
+type selectState struct {
+	items        []selectItem
+	filter       string
+	selected     int
+	scrollOffset int
+}
+
+func newSelectState(items []selectItem) *selectState {
+	return &selectState{items: items}
+}
+
+func (s *selectState) filtered() []selectItem {
+	return filterItems(s.items, s.filter)
+}
+
+func (s *selectState) handleInput(event inputEvent, char byte) (done bool, result string, err error) {
+	filtered := s.filtered()
+
+	switch event {
+	case eventEnter:
+		if len(filtered) > 0 && s.selected < len(filtered) {
+			return true, filtered[s.selected].Name, nil
+		}
+	case eventEscape:
+		return true, "", errCancelled
+	case eventBackspace:
+		if len(s.filter) > 0 {
+			s.filter = s.filter[:len(s.filter)-1]
+			s.selected = 0
+			s.scrollOffset = 0
+		}
+	case eventUp:
+		if s.selected > 0 {
+			s.selected--
+			if s.selected < s.scrollOffset {
+				s.scrollOffset = s.selected
+			}
+		}
+	case eventDown:
+		if s.selected < len(filtered)-1 {
+			s.selected++
+			if s.selected >= s.scrollOffset+maxDisplayedItems {
+				s.scrollOffset = s.selected - maxDisplayedItems + 1
+			}
+		}
+	case eventChar:
+		s.filter += string(char)
+		s.selected = 0
+		s.scrollOffset = 0
 	}
 
+	return false, "", nil
+}
+
+type multiSelectState struct {
+	items         []selectItem
+	itemIndex     map[string]int
+	filter        string
+	highlighted   int
+	scrollOffset  int
+	checked       map[int]bool
+	checkOrder    []int
+	focusOnButton bool
+}
+
+func newMultiSelectState(items []selectItem, preChecked []string) *multiSelectState {
+	s := &multiSelectState{
+		items:     items,
+		itemIndex: make(map[string]int, len(items)),
+		checked:   make(map[int]bool),
+	}
+
+	for i, item := range items {
+		s.itemIndex[item.Name] = i
+	}
+
+	for _, name := range preChecked {
+		if idx, ok := s.itemIndex[name]; ok {
+			s.checked[idx] = true
+			s.checkOrder = append(s.checkOrder, idx)
+		}
+	}
+
+	return s
+}
+
+func (s *multiSelectState) filtered() []selectItem {
+	return filterItems(s.items, s.filter)
+}
+
+func (s *multiSelectState) toggleItem() {
+	filtered := s.filtered()
+	if len(filtered) == 0 || s.highlighted >= len(filtered) {
+		return
+	}
+
+	item := filtered[s.highlighted]
+	origIdx := s.itemIndex[item.Name]
+
+	if s.checked[origIdx] {
+		delete(s.checked, origIdx)
+		for i, idx := range s.checkOrder {
+			if idx == origIdx {
+				s.checkOrder = append(s.checkOrder[:i], s.checkOrder[i+1:]...)
+				break
+			}
+		}
+	} else {
+		s.checked[origIdx] = true
+		s.checkOrder = append(s.checkOrder, origIdx)
+	}
+}
+
+func (s *multiSelectState) handleInput(event inputEvent, char byte) (done bool, result []string, err error) {
+	filtered := s.filtered()
+
+	switch event {
+	case eventEnter:
+		if s.focusOnButton && len(s.checkOrder) > 0 {
+			var res []string
+			for _, idx := range s.checkOrder {
+				res = append(res, s.items[idx].Name)
+			}
+			return true, res, nil
+		} else if !s.focusOnButton {
+			s.toggleItem()
+		}
+	case eventTab:
+		if len(s.checkOrder) > 0 {
+			s.focusOnButton = !s.focusOnButton
+		}
+	case eventEscape:
+		return true, nil, errCancelled
+	case eventBackspace:
+		if len(s.filter) > 0 {
+			s.filter = s.filter[:len(s.filter)-1]
+			s.highlighted = 0
+			s.scrollOffset = 0
+			s.focusOnButton = false
+		}
+	case eventUp:
+		if s.focusOnButton {
+			s.focusOnButton = false
+		} else if s.highlighted > 0 {
+			s.highlighted--
+			if s.highlighted < s.scrollOffset {
+				s.scrollOffset = s.highlighted
+			}
+		}
+	case eventDown:
+		if s.focusOnButton {
+			s.focusOnButton = false
+		} else if s.highlighted < len(filtered)-1 {
+			s.highlighted++
+			if s.highlighted >= s.scrollOffset+maxDisplayedItems {
+				s.scrollOffset = s.highlighted - maxDisplayedItems + 1
+			}
+		}
+	case eventChar:
+		s.filter += string(char)
+		s.highlighted = 0
+		s.scrollOffset = 0
+		s.focusOnButton = false
+	}
+
+	return false, nil, nil
+}
+
+func (s *multiSelectState) selectedCount() int {
+	return len(s.checkOrder)
+}
+
+// Terminal I/O handling
+
+type terminalState struct {
+	fd       int
+	oldState *term.State
+}
+
+func enterRawMode() (*terminalState, error) {
+	fd := int(os.Stdin.Fd())
+	oldState, err := term.MakeRaw(fd)
+	if err != nil {
+		return nil, err
+	}
+	fmt.Fprint(os.Stderr, ansiHideCursor)
+	return &terminalState{fd: fd, oldState: oldState}, nil
+}
+
+func (t *terminalState) restore() {
+	fmt.Fprint(os.Stderr, ansiShowCursor)
+	term.Restore(t.fd, t.oldState)
+}
+
+func clearLines(n int) {
+	if n > 0 {
+		fmt.Fprintf(os.Stderr, "\033[%dA", n)
+		fmt.Fprint(os.Stderr, ansiClearDown)
+	}
+}
+
+func parseInput(r io.Reader) (inputEvent, byte, error) {
+	buf := make([]byte, 3)
+	n, err := r.Read(buf)
+	if err != nil {
+		return 0, 0, err
+	}
+
+	switch {
+	case n == 1 && buf[0] == 13:
+		return eventEnter, 0, nil
+	case n == 1 && (buf[0] == 3 || buf[0] == 27):
+		return eventEscape, 0, nil
+	case n == 1 && buf[0] == 9:
+		return eventTab, 0, nil
+	case n == 1 && buf[0] == 127:
+		return eventBackspace, 0, nil
+	case n == 3 && buf[0] == 27 && buf[1] == 91 && buf[2] == 65:
+		return eventUp, 0, nil
+	case n == 3 && buf[0] == 27 && buf[1] == 91 && buf[2] == 66:
+		return eventDown, 0, nil
+	case n == 1 && buf[0] >= 32 && buf[0] < 127:
+		return eventChar, buf[0], nil
+	}
+
+	return eventNone, 0, nil
+}
+
+// Rendering
+
+func renderSelect(w io.Writer, prompt string, s *selectState) int {
+	filtered := s.filtered()
+
+	if s.filter == "" {
+		fmt.Fprintf(w, "%s %sType to filter...%s\r\n", prompt, ansiGray, ansiReset)
+	} else {
+		fmt.Fprintf(w, "%s %s\r\n", prompt, s.filter)
+	}
+	lineCount := 1
+
+	if len(filtered) == 0 {
+		fmt.Fprintf(w, "  %s(no matches)%s\r\n", ansiGray, ansiReset)
+		lineCount++
+	} else {
+		displayCount := min(len(filtered), maxDisplayedItems)
+
+		for i := range displayCount {
+			idx := s.scrollOffset + i
+			if idx >= len(filtered) {
+				break
+			}
+			item := filtered[idx]
+			prefix := "    "
+			if idx == s.selected {
+				prefix = "  " + ansiBold + "> "
+			}
+			if item.Description != "" {
+				fmt.Fprintf(w, "%s%s%s %s- %s%s\r\n", prefix, item.Name, ansiReset, ansiGray, item.Description, ansiReset)
+			} else {
+				fmt.Fprintf(w, "%s%s%s\r\n", prefix, item.Name, ansiReset)
+			}
+			lineCount++
+		}
+
+		if remaining := len(filtered) - s.scrollOffset - displayCount; remaining > 0 {
+			fmt.Fprintf(w, "  %s... and %d more%s\r\n", ansiGray, remaining, ansiReset)
+			lineCount++
+		}
+	}
+
+	return lineCount
+}
+
+func renderMultiSelect(w io.Writer, prompt string, s *multiSelectState) int {
+	filtered := s.filtered()
+
+	if s.filter == "" {
+		fmt.Fprintf(w, "%s %sType to filter...%s\r\n", prompt, ansiGray, ansiReset)
+	} else {
+		fmt.Fprintf(w, "%s %s\r\n", prompt, s.filter)
+	}
+	lineCount := 1
+
+	if len(filtered) == 0 {
+		fmt.Fprintf(w, "  %s(no matches)%s\r\n", ansiGray, ansiReset)
+		lineCount++
+	} else {
+		displayCount := min(len(filtered), maxDisplayedItems)
+
+		for i := range displayCount {
+			idx := s.scrollOffset + i
+			if idx >= len(filtered) {
+				break
+			}
+			item := filtered[idx]
+			origIdx := s.itemIndex[item.Name]
+
+			checkbox := "[ ]"
+			if s.checked[origIdx] {
+				checkbox = "[x]"
+			}
+
+			prefix := "  "
+			suffix := ""
+			if idx == s.highlighted && !s.focusOnButton {
+				prefix = "> "
+			}
+			if len(s.checkOrder) > 0 && s.checkOrder[0] == origIdx {
+				suffix = " " + ansiGray + "(default)" + ansiReset
+			}
+
+			desc := ""
+			if item.Description != "" {
+				desc = " " + ansiGray + "- " + item.Description + ansiReset
+			}
+
+			if idx == s.highlighted && !s.focusOnButton {
+				fmt.Fprintf(w, "  %s%s %s %s%s%s%s\r\n", ansiBold, prefix, checkbox, item.Name, ansiReset, desc, suffix)
+			} else {
+				fmt.Fprintf(w, "  %s %s %s%s%s\r\n", prefix, checkbox, item.Name, desc, suffix)
+			}
+			lineCount++
+		}
+
+		if remaining := len(filtered) - s.scrollOffset - displayCount; remaining > 0 {
+			fmt.Fprintf(w, "  %s... and %d more%s\r\n", ansiGray, remaining, ansiReset)
+			lineCount++
+		}
+	}
+
+	fmt.Fprintf(w, "\r\n")
+	lineCount++
+	count := s.selectedCount()
+	switch {
+	case count == 0:
+		fmt.Fprintf(w, "  %sSelect at least one model.%s\r\n", ansiGray, ansiReset)
+	case s.focusOnButton:
+		fmt.Fprintf(w, "  %s> [ Continue ]%s %s(%d selected)%s\r\n", ansiBold, ansiReset, ansiGray, count, ansiReset)
+	default:
+		fmt.Fprintf(w, "    %s[ Continue ] (%d selected) - press Tab%s\r\n", ansiGray, count, ansiReset)
+	}
+	lineCount++
+
+	return lineCount
+}
+
+// selectPrompt prompts the user to select a single item from a list.
+func selectPrompt(prompt string, items []selectItem) (string, error) {
+	if len(items) == 0 {
+		return "", fmt.Errorf("no items to select from")
+	}
+
+	ts, err := enterRawMode()
+	if err != nil {
+		return "", err
+	}
+	defer ts.restore()
+
+	state := newSelectState(items)
+	var lastLineCount int
+
+	render := func() {
+		clearLines(lastLineCount)
+		lastLineCount = renderSelect(os.Stderr, prompt, state)
+	}
+
+	render()
+
+	for {
+		event, char, err := parseInput(os.Stdin)
+		if err != nil {
+			return "", err
+		}
+
+		done, result, err := state.handleInput(event, char)
+		if done {
+			clearLines(lastLineCount)
+			if err != nil {
+				return "", err
+			}
+			return result, nil
+		}
+
+		render()
+	}
+}
+
+// multiSelectPrompt prompts the user to select multiple items from a list.
+func multiSelectPrompt(prompt string, items []selectItem, preChecked []string) ([]string, error) {
+	if len(items) == 0 {
+		return nil, fmt.Errorf("no items to select from")
+	}
+
+	ts, err := enterRawMode()
+	if err != nil {
+		return nil, err
+	}
+	defer ts.restore()
+
+	state := newMultiSelectState(items, preChecked)
+	var lastLineCount int
+
+	render := func() {
+		clearLines(lastLineCount)
+		lastLineCount = renderMultiSelect(os.Stderr, prompt, state)
+	}
+
+	render()
+
+	for {
+		event, char, err := parseInput(os.Stdin)
+		if err != nil {
+			return nil, err
+		}
+
+		done, result, err := state.handleInput(event, char)
+		if done {
+			clearLines(lastLineCount)
+			if err != nil {
+				return nil, err
+			}
+			return result, nil
+		}
+
+		render()
+	}
+}
+
+func confirmPrompt(prompt string) (bool, error) {
 	fd := int(os.Stdin.Fd())
 	oldState, err := term.MakeRaw(fd)
 	if err != nil {
@@ -56,3 +497,17 @@ func confirmPrompt(prompt string) (bool, error) {
 		}
 	}
 }
+
+func filterItems(items []selectItem, filter string) []selectItem {
+	if filter == "" {
+		return items
+	}
+	var result []selectItem
+	filterLower := strings.ToLower(filter)
+	for _, item := range items {
+		if strings.Contains(strings.ToLower(item.Name), filterLower) {
+			result = append(result, item)
+		}
+	}
+	return result
+}

cmd/config/selector_test.go

@@ -1,9 +1,670 @@
 package config
 
 import (
+	"bytes"
+	"strings"
 	"testing"
 )
 
+func TestFilterItems(t *testing.T) {
+	items := []selectItem{
+		{Name: "llama3.2:latest"},
+		{Name: "qwen2.5:7b"},
+		{Name: "deepseek-v3:cloud"},
+		{Name: "GPT-OSS:20b"},
+	}
+
+	t.Run("EmptyFilter_ReturnsAllItems", func(t *testing.T) {
+		result := filterItems(items, "")
+		if len(result) != len(items) {
+			t.Errorf("expected %d items, got %d", len(items), len(result))
+		}
+	})
+
+	t.Run("CaseInsensitive_UppercaseFilterMatchesLowercase", func(t *testing.T) {
+		result := filterItems(items, "LLAMA")
+		if len(result) != 1 || result[0].Name != "llama3.2:latest" {
+			t.Errorf("expected llama3.2:latest, got %v", result)
+		}
+	})
+
+	t.Run("CaseInsensitive_LowercaseFilterMatchesUppercase", func(t *testing.T) {
+		result := filterItems(items, "gpt")
+		if len(result) != 1 || result[0].Name != "GPT-OSS:20b" {
+			t.Errorf("expected GPT-OSS:20b, got %v", result)
+		}
+	})
+
+	t.Run("PartialMatch", func(t *testing.T) {
+		result := filterItems(items, "deep")
+		if len(result) != 1 || result[0].Name != "deepseek-v3:cloud" {
+			t.Errorf("expected deepseek-v3:cloud, got %v", result)
+		}
+	})
+
+	t.Run("NoMatch_ReturnsEmpty", func(t *testing.T) {
+		result := filterItems(items, "nonexistent")
+		if len(result) != 0 {
+			t.Errorf("expected 0 items, got %d", len(result))
+		}
+	})
+}
+
+func TestSelectState(t *testing.T) {
+	items := []selectItem{
+		{Name: "item1"},
+		{Name: "item2"},
+		{Name: "item3"},
+	}
+
+	t.Run("InitialState", func(t *testing.T) {
+		s := newSelectState(items)
+		if s.selected != 0 {
+			t.Errorf("expected selected=0, got %d", s.selected)
+		}
+		if s.filter != "" {
+			t.Errorf("expected empty filter, got %q", s.filter)
+		}
+		if s.scrollOffset != 0 {
+			t.Errorf("expected scrollOffset=0, got %d", s.scrollOffset)
+		}
+	})
+
+	t.Run("Enter_SelectsCurrentItem", func(t *testing.T) {
+		s := newSelectState(items)
+		done, result, err := s.handleInput(eventEnter, 0)
+		if !done || result != "item1" || err != nil {
+			t.Errorf("expected (true, item1, nil), got (%v, %v, %v)", done, result, err)
+		}
+	})
+
+	t.Run("Enter_WithFilter_SelectsFilteredItem", func(t *testing.T) {
+		s := newSelectState(items)
+		s.filter = "item3"
+		done, result, err := s.handleInput(eventEnter, 0)
+		if !done || result != "item3" || err != nil {
+			t.Errorf("expected (true, item3, nil), got (%v, %v, %v)", done, result, err)
+		}
+	})
+
+	t.Run("Enter_EmptyFilteredList_DoesNothing", func(t *testing.T) {
+		s := newSelectState(items)
+		s.filter = "nonexistent"
+		done, result, err := s.handleInput(eventEnter, 0)
+		if done || result != "" || err != nil {
+			t.Errorf("expected (false, '', nil), got (%v, %v, %v)", done, result, err)
+		}
+	})
+
+	t.Run("Enter_EmptyFilteredList_EmptyFilter_DoesNothing", func(t *testing.T) {
+		s := newSelectState([]selectItem{})
+		done, result, err := s.handleInput(eventEnter, 0)
+		if done || result != "" || err != nil {
+			t.Errorf("expected (false, '', nil), got (%v, %v, %v)", done, result, err)
+		}
+	})
+
+	t.Run("Escape_ReturnsCancelledError", func(t *testing.T) {
+		s := newSelectState(items)
+		done, result, err := s.handleInput(eventEscape, 0)
+		if !done || result != "" || err != errCancelled {
+			t.Errorf("expected (true, '', errCancelled), got (%v, %v, %v)", done, result, err)
+		}
+	})
+
+	t.Run("Down_MovesSelection", func(t *testing.T) {
+		s := newSelectState(items)
+		s.handleInput(eventDown, 0)
+		if s.selected != 1 {
+			t.Errorf("expected selected=1, got %d", s.selected)
+		}
+	})
+
+	t.Run("Down_AtBottom_StaysAtBottom", func(t *testing.T) {
+		s := newSelectState(items)
+		s.selected = 2
+		s.handleInput(eventDown, 0)
+		if s.selected != 2 {
+			t.Errorf("expected selected=2 (stayed at bottom), got %d", s.selected)
+		}
+	})
+
+	t.Run("Up_MovesSelection", func(t *testing.T) {
+		s := newSelectState(items)
+		s.selected = 2
+		s.handleInput(eventUp, 0)
+		if s.selected != 1 {
+			t.Errorf("expected selected=1, got %d", s.selected)
+		}
+	})
+
+	t.Run("Up_AtTop_StaysAtTop", func(t *testing.T) {
+		s := newSelectState(items)
+		s.handleInput(eventUp, 0)
+		if s.selected != 0 {
+			t.Errorf("expected selected=0 (stayed at top), got %d", s.selected)
+		}
+	})
+
+	t.Run("Char_AppendsToFilter", func(t *testing.T) {
+		s := newSelectState(items)
+		s.handleInput(eventChar, 'i')
+		s.handleInput(eventChar, 't')
+		s.handleInput(eventChar, 'e')
+		s.handleInput(eventChar, 'm')
+		s.handleInput(eventChar, '2')
+		if s.filter != "item2" {
+			t.Errorf("expected filter='item2', got %q", s.filter)
+		}
+		filtered := s.filtered()
+		if len(filtered) != 1 || filtered[0].Name != "item2" {
+			t.Errorf("expected [item2], got %v", filtered)
+		}
+	})
+
+	t.Run("Char_ResetsSelectionToZero", func(t *testing.T) {
+		s := newSelectState(items)
+		s.selected = 2
+		s.handleInput(eventChar, 'x')
+		if s.selected != 0 {
+			t.Errorf("expected selected=0 after typing, got %d", s.selected)
+		}
+	})
+
+	t.Run("Backspace_RemovesLastFilterChar", func(t *testing.T) {
+		s := newSelectState(items)
+		s.filter = "test"
+		s.handleInput(eventBackspace, 0)
+		if s.filter != "tes" {
+			t.Errorf("expected filter='tes', got %q", s.filter)
+		}
+	})
+
+	t.Run("Backspace_EmptyFilter_DoesNothing", func(t *testing.T) {
+		s := newSelectState(items)
+		s.handleInput(eventBackspace, 0)
+		if s.filter != "" {
+			t.Errorf("expected filter='', got %q", s.filter)
+		}
+	})
+
+	t.Run("Backspace_ResetsSelectionToZero", func(t *testing.T) {
+		s := newSelectState(items)
+		s.filter = "test"
+		s.selected = 2
+		s.handleInput(eventBackspace, 0)
+		if s.selected != 0 {
+			t.Errorf("expected selected=0 after backspace, got %d", s.selected)
+		}
+	})
+
+	t.Run("Scroll_DownPastVisibleItems_ScrollsViewport", func(t *testing.T) {
+		// maxDisplayedItems is 10, so with 15 items we need to scroll
+		manyItems := make([]selectItem, 15)
+		for i := range manyItems {
+			manyItems[i] = selectItem{Name: string(rune('a' + i))}
+		}
+		s := newSelectState(manyItems)
+
+		// move down 12 times (past the 10-item viewport)
+		for range 12 {
+			s.handleInput(eventDown, 0)
+		}
+
+		if s.selected != 12 {
+			t.Errorf("expected selected=12, got %d", s.selected)
+		}
+		if s.scrollOffset != 3 {
+			t.Errorf("expected scrollOffset=3 (12-10+1), got %d", s.scrollOffset)
+		}
+	})
+
+	t.Run("Scroll_UpPastScrollOffset_ScrollsViewport", func(t *testing.T) {
+		manyItems := make([]selectItem, 15)
+		for i := range manyItems {
+			manyItems[i] = selectItem{Name: string(rune('a' + i))}
+		}
+		s := newSelectState(manyItems)
+		s.selected = 5
+		s.scrollOffset = 5
+
+		s.handleInput(eventUp, 0)
+
+		if s.selected != 4 {
+			t.Errorf("expected selected=4, got %d", s.selected)
+		}
+		if s.scrollOffset != 4 {
+			t.Errorf("expected scrollOffset=4, got %d", s.scrollOffset)
+		}
+	})
+}
+
+func TestMultiSelectState(t *testing.T) {
+	items := []selectItem{
+		{Name: "item1"},
+		{Name: "item2"},
+		{Name: "item3"},
+	}
+
+	t.Run("InitialState_NoPrechecked", func(t *testing.T) {
+		s := newMultiSelectState(items, nil)
+		if s.highlighted != 0 {
+			t.Errorf("expected highlighted=0, got %d", s.highlighted)
+		}
+		if s.selectedCount() != 0 {
+			t.Errorf("expected 0 selected, got %d", s.selectedCount())
+		}
+		if s.focusOnButton {
+			t.Error("expected focusOnButton=false initially")
+		}
+	})
+
+	t.Run("InitialState_WithPrechecked", func(t *testing.T) {
+		s := newMultiSelectState(items, []string{"item2", "item3"})
+		if s.selectedCount() != 2 {
+			t.Errorf("expected 2 selected, got %d", s.selectedCount())
+		}
+		if !s.checked[1] || !s.checked[2] {
+			t.Error("expected item2 and item3 to be checked")
+		}
+	})
+
+	t.Run("Prechecked_PreservesSelectionOrder", func(t *testing.T) {
+		// order matters: first checked = default model
+		s := newMultiSelectState(items, []string{"item3", "item1"})
+		if len(s.checkOrder) != 2 {
+			t.Fatalf("expected 2 in checkOrder, got %d", len(s.checkOrder))
+		}
+		if s.checkOrder[0] != 2 || s.checkOrder[1] != 0 {
+			t.Errorf("expected checkOrder=[2,0] (item3 first), got %v", s.checkOrder)
+		}
+	})
+
+	t.Run("Prechecked_IgnoresInvalidNames", func(t *testing.T) {
+		s := newMultiSelectState(items, []string{"item1", "nonexistent"})
+		if s.selectedCount() != 1 {
+			t.Errorf("expected 1 selected (nonexistent ignored), got %d", s.selectedCount())
+		}
+	})
+
+	t.Run("Toggle_ChecksUncheckedItem", func(t *testing.T) {
+		s := newMultiSelectState(items, nil)
+		s.toggleItem()
+		if !s.checked[0] {
+			t.Error("expected item1 to be checked after toggle")
+		}
+	})
+
+	t.Run("Toggle_UnchecksCheckedItem", func(t *testing.T) {
+		s := newMultiSelectState(items, []string{"item1"})
+		s.toggleItem()
+		if s.checked[0] {
+			t.Error("expected item1 to be unchecked after toggle")
+		}
+	})
+
+	t.Run("Toggle_RemovesFromCheckOrder", func(t *testing.T) {
+		s := newMultiSelectState(items, []string{"item1", "item2", "item3"})
+		s.highlighted = 1 // toggle item2
+		s.toggleItem()
+
+		if len(s.checkOrder) != 2 {
+			t.Fatalf("expected 2 in checkOrder, got %d", len(s.checkOrder))
+		}
+		// should be [0, 2] (item1, item3) with item2 removed
+		if s.checkOrder[0] != 0 || s.checkOrder[1] != 2 {
+			t.Errorf("expected checkOrder=[0,2], got %v", s.checkOrder)
+		}
+	})
+
+	t.Run("Enter_TogglesWhenNotOnButton", func(t *testing.T) {
+		s := newMultiSelectState(items, nil)
+		s.handleInput(eventEnter, 0)
+		if !s.checked[0] {
+			t.Error("expected item1 to be checked after enter")
+		}
+	})
+
+	t.Run("Enter_OnButton_ReturnsSelection", func(t *testing.T) {
+		s := newMultiSelectState(items, []string{"item2", "item1"})
+		s.focusOnButton = true
+
+		done, result, err := s.handleInput(eventEnter, 0)
+
+		if !done || err != nil {
+			t.Errorf("expected done=true, err=nil, got done=%v, err=%v", done, err)
+		}
+		// result should preserve selection order
+		if len(result) != 2 || result[0] != "item2" || result[1] != "item1" {
+			t.Errorf("expected [item2, item1], got %v", result)
+		}
+	})
+
+	t.Run("Enter_OnButton_EmptySelection_DoesNothing", func(t *testing.T) {
+		s := newMultiSelectState(items, nil)
+		s.focusOnButton = true
+		done, result, err := s.handleInput(eventEnter, 0)
+		if done || result != nil || err != nil {
+			t.Errorf("expected (false, nil, nil), got (%v, %v, %v)", done, result, err)
+		}
+	})
+
+	t.Run("Tab_SwitchesToButton_WhenHasSelection", func(t *testing.T) {
+		s := newMultiSelectState(items, []string{"item1"})
+		s.handleInput(eventTab, 0)
+		if !s.focusOnButton {
+			t.Error("expected focus on button after tab")
+		}
+	})
+
+	t.Run("Tab_DoesNothing_WhenNoSelection", func(t *testing.T) {
+		s := newMultiSelectState(items, nil)
+		s.handleInput(eventTab, 0)
+		if s.focusOnButton {
+			t.Error("tab should not focus button when nothing selected")
+		}
+	})
+
+	t.Run("Tab_TogglesButtonFocus", func(t *testing.T) {
+		s := newMultiSelectState(items, []string{"item1"})
+		s.handleInput(eventTab, 0)
+		if !s.focusOnButton {
+			t.Error("expected focus on button after first tab")
+		}
+		s.handleInput(eventTab, 0)
+		if s.focusOnButton {
+			t.Error("expected focus back on list after second tab")
+		}
+	})
+
+	t.Run("Escape_ReturnsCancelledError", func(t *testing.T) {
+		s := newMultiSelectState(items, []string{"item1"})
+		done, result, err := s.handleInput(eventEscape, 0)
+		if !done || result != nil || err != errCancelled {
+			t.Errorf("expected (true, nil, errCancelled), got (%v, %v, %v)", done, result, err)
+		}
+	})
+
+	t.Run("IsDefault_TrueForFirstChecked", func(t *testing.T) {
+		s := newMultiSelectState(items, []string{"item2", "item1"})
+		if !(len(s.checkOrder) > 0 && s.checkOrder[0] == 1) {
+			t.Error("expected item2 (idx 1) to be default (first checked)")
+		}
+		if len(s.checkOrder) > 0 && s.checkOrder[0] == 0 {
+			t.Error("expected item1 (idx 0) to NOT be default")
+		}
+	})
+
+	t.Run("IsDefault_FalseWhenNothingChecked", func(t *testing.T) {
+		s := newMultiSelectState(items, nil)
+		if len(s.checkOrder) > 0 && s.checkOrder[0] == 0 {
+			t.Error("expected isDefault=false when nothing checked")
+		}
+	})
+
+	t.Run("Down_MovesHighlight", func(t *testing.T) {
+		s := newMultiSelectState(items, nil)
+		s.handleInput(eventDown, 0)
+		if s.highlighted != 1 {
+			t.Errorf("expected highlighted=1, got %d", s.highlighted)
+		}
+	})
+
+	t.Run("Up_MovesHighlight", func(t *testing.T) {
+		s := newMultiSelectState(items, nil)
+		s.highlighted = 1
+		s.handleInput(eventUp, 0)
+		if s.highlighted != 0 {
+			t.Errorf("expected highlighted=0, got %d", s.highlighted)
+		}
+	})
+
+	t.Run("Arrow_ReturnsFocusFromButton", func(t *testing.T) {
+		s := newMultiSelectState(items, []string{"item1"})
+		s.focusOnButton = true
+		s.handleInput(eventDown, 0)
+		if s.focusOnButton {
+			t.Error("expected focus to return to list on arrow key")
+		}
+	})
+
+	t.Run("Char_AppendsToFilter", func(t *testing.T) {
+		s := newMultiSelectState(items, nil)
+		s.handleInput(eventChar, 'x')
+		if s.filter != "x" {
+			t.Errorf("expected filter='x', got %q", s.filter)
+		}
+	})
+
+	t.Run("Char_ResetsHighlightAndScroll", func(t *testing.T) {
+		manyItems := make([]selectItem, 15)
+		for i := range manyItems {
+			manyItems[i] = selectItem{Name: string(rune('a' + i))}
+		}
+		s := newMultiSelectState(manyItems, nil)
+		s.highlighted = 10
+		s.scrollOffset = 5
+
+		s.handleInput(eventChar, 'x')
+
+		if s.highlighted != 0 {
+			t.Errorf("expected highlighted=0, got %d", s.highlighted)
+		}
+		if s.scrollOffset != 0 {
+			t.Errorf("expected scrollOffset=0, got %d", s.scrollOffset)
+		}
+	})
+
+	t.Run("Backspace_RemovesLastFilterChar", func(t *testing.T) {
+		s := newMultiSelectState(items, nil)
+		s.filter = "test"
+		s.handleInput(eventBackspace, 0)
+		if s.filter != "tes" {
+			t.Errorf("expected filter='tes', got %q", s.filter)
+		}
+	})
+
+	t.Run("Backspace_RemovesFocusFromButton", func(t *testing.T) {
+		s := newMultiSelectState(items, []string{"item1"})
+		s.filter = "x"
+		s.focusOnButton = true
+		s.handleInput(eventBackspace, 0)
+		if s.focusOnButton {
+			t.Error("expected focusOnButton=false after backspace")
+		}
+	})
+}
+
+func TestParseInput(t *testing.T) {
+	t.Run("Enter", func(t *testing.T) {
+		event, char, err := parseInput(bytes.NewReader([]byte{13}))
+		if err != nil || event != eventEnter || char != 0 {
+			t.Errorf("expected (eventEnter, 0, nil), got (%v, %v, %v)", event, char, err)
+		}
+	})
+
+	t.Run("Escape", func(t *testing.T) {
+		event, _, err := parseInput(bytes.NewReader([]byte{27}))
+		if err != nil || event != eventEscape {
+			t.Errorf("expected eventEscape, got %v", event)
+		}
+	})
+
+	t.Run("CtrlC_TreatedAsEscape", func(t *testing.T) {
+		event, _, err := parseInput(bytes.NewReader([]byte{3}))
+		if err != nil || event != eventEscape {
+			t.Errorf("expected eventEscape for Ctrl+C, got %v", event)
+		}
+	})
+
+	t.Run("Tab", func(t *testing.T) {
+		event, _, err := parseInput(bytes.NewReader([]byte{9}))
+		if err != nil || event != eventTab {
+			t.Errorf("expected eventTab, got %v", event)
+		}
+	})
+
+	t.Run("Backspace", func(t *testing.T) {
+		event, _, err := parseInput(bytes.NewReader([]byte{127}))
+		if err != nil || event != eventBackspace {
+			t.Errorf("expected eventBackspace, got %v", event)
+		}
+	})
+
+	t.Run("UpArrow", func(t *testing.T) {
+		event, _, err := parseInput(bytes.NewReader([]byte{27, 91, 65}))
+		if err != nil || event != eventUp {
+			t.Errorf("expected eventUp, got %v", event)
+		}
+	})
+
+	t.Run("DownArrow", func(t *testing.T) {
+		event, _, err := parseInput(bytes.NewReader([]byte{27, 91, 66}))
+		if err != nil || event != eventDown {
+			t.Errorf("expected eventDown, got %v", event)
+		}
+	})
+
+	t.Run("PrintableChars", func(t *testing.T) {
+		tests := []struct {
+			name string
+			char byte
+		}{
+			{"lowercase", 'a'},
+			{"uppercase", 'Z'},
+			{"digit", '5'},
+			{"space", ' '},
+			{"tilde", '~'},
+		}
+		for _, tt := range tests {
+			t.Run(tt.name, func(t *testing.T) {
+				event, char, err := parseInput(bytes.NewReader([]byte{tt.char}))
+				if err != nil || event != eventChar || char != tt.char {
+					t.Errorf("expected (eventChar, %q), got (%v, %q)", tt.char, event, char)
+				}
+			})
+		}
+	})
+}
+
+func TestRenderSelect(t *testing.T) {
+	items := []selectItem{
+		{Name: "item1", Description: "first item"},
+		{Name: "item2"},
+	}
+
+	t.Run("ShowsPromptAndItems", func(t *testing.T) {
+		s := newSelectState(items)
+		var buf bytes.Buffer
+		lineCount := renderSelect(&buf, "Select:", s)
+
+		output := buf.String()
+		if !strings.Contains(output, "Select:") {
+			t.Error("expected prompt in output")
+		}
+		if !strings.Contains(output, "item1") {
+			t.Error("expected item1 in output")
+		}
+		if !strings.Contains(output, "first item") {
+			t.Error("expected description in output")
+		}
+		if !strings.Contains(output, "item2") {
+			t.Error("expected item2 in output")
+		}
+		if lineCount != 3 { // 1 prompt + 2 items
+			t.Errorf("expected 3 lines, got %d", lineCount)
+		}
+	})
+
+	t.Run("EmptyFilteredList_ShowsNoMatches", func(t *testing.T) {
+		s := newSelectState(items)
+		s.filter = "xyz"
+		var buf bytes.Buffer
+		renderSelect(&buf, "Select:", s)
+
+		output := buf.String()
+		if !strings.Contains(output, "no matches") {
+			t.Errorf("expected 'no matches' message, got: %s", output)
+		}
+	})
+
+	t.Run("EmptyFilteredList_EmptyFilter_ShowsNoMatches", func(t *testing.T) {
+		s := newSelectState([]selectItem{})
+		var buf bytes.Buffer
+		renderSelect(&buf, "Select:", s)
+
+		if !strings.Contains(buf.String(), "no matches") {
+			t.Error("expected 'no matches' message for empty list with no filter")
+		}
+	})
+
+	t.Run("LongList_ShowsRemainingCount", func(t *testing.T) {
+		manyItems := make([]selectItem, 15)
+		for i := range manyItems {
+			manyItems[i] = selectItem{Name: string(rune('a' + i))}
+		}
+		s := newSelectState(manyItems)
+		var buf bytes.Buffer
+		renderSelect(&buf, "Select:", s)
+
+		// 15 items - 10 displayed = 5 more
+		if !strings.Contains(buf.String(), "5 more") {
+			t.Error("expected '5 more' indicator")
+		}
+	})
+}
+
+func TestRenderMultiSelect(t *testing.T) {
+	items := []selectItem{
+		{Name: "item1"},
+		{Name: "item2"},
+	}
+
+	t.Run("ShowsCheckboxes", func(t *testing.T) {
+		s := newMultiSelectState(items, []string{"item1"})
+		var buf bytes.Buffer
+		renderMultiSelect(&buf, "Select:", s)
+
+		output := buf.String()
+		if !strings.Contains(output, "[x]") {
+			t.Error("expected checked checkbox [x]")
+		}
+		if !strings.Contains(output, "[ ]") {
+			t.Error("expected unchecked checkbox [ ]")
+		}
+	})
+
+	t.Run("ShowsDefaultMarker", func(t *testing.T) {
+		s := newMultiSelectState(items, []string{"item1"})
+		var buf bytes.Buffer
+		renderMultiSelect(&buf, "Select:", s)
+
+		if !strings.Contains(buf.String(), "(default)") {
+			t.Error("expected (default) marker for first checked item")
+		}
+	})
+
+	t.Run("ShowsSelectedCount", func(t *testing.T) {
+		s := newMultiSelectState(items, []string{"item1", "item2"})
+		var buf bytes.Buffer
+		renderMultiSelect(&buf, "Select:", s)
+
+		if !strings.Contains(buf.String(), "2 selected") {
+			t.Error("expected '2 selected' in output")
+		}
+	})
+
+	t.Run("NoSelection_ShowsHelperText", func(t *testing.T) {
+		s := newMultiSelectState(items, nil)
+		var buf bytes.Buffer
+		renderMultiSelect(&buf, "Select:", s)
+
+		if !strings.Contains(buf.String(), "Select at least one") {
+			t.Error("expected 'Select at least one' helper text")
+		}
+	})
+}
+
 func TestErrCancelled(t *testing.T) {
 	t.Run("NotNil", func(t *testing.T) {
 		if errCancelled == nil {
@@ -17,3 +678,255 @@ func TestErrCancelled(t *testing.T) {
 		}
 	})
 }
+
+// Edge case tests for selector.go
+
+// TestSelectState_SingleItem verifies that single item list works without crash.
+// List with only one item should still work.
+func TestSelectState_SingleItem(t *testing.T) {
+	items := []selectItem{{Name: "only-one"}}
+
+	s := newSelectState(items)
+
+	// Down should do nothing (already at bottom)
+	s.handleInput(eventDown, 0)
+	if s.selected != 0 {
+		t.Errorf("down on single item: expected selected=0, got %d", s.selected)
+	}
+
+	// Up should do nothing (already at top)
+	s.handleInput(eventUp, 0)
+	if s.selected != 0 {
+		t.Errorf("up on single item: expected selected=0, got %d", s.selected)
+	}
+
+	// Enter should select the only item
+	done, result, err := s.handleInput(eventEnter, 0)
+	if !done || result != "only-one" || err != nil {
+		t.Errorf("enter on single item: expected (true, 'only-one', nil), got (%v, %q, %v)", done, result, err)
+	}
+}
+
+// TestSelectState_ExactlyMaxItems verifies boundary condition at maxDisplayedItems.
+// List with exactly maxDisplayedItems items should not scroll.
+func TestSelectState_ExactlyMaxItems(t *testing.T) {
+	items := make([]selectItem, maxDisplayedItems)
+	for i := range items {
+		items[i] = selectItem{Name: string(rune('a' + i))}
+	}
+
+	s := newSelectState(items)
+
+	// Move to last item
+	for range maxDisplayedItems - 1 {
+		s.handleInput(eventDown, 0)
+	}
+
+	if s.selected != maxDisplayedItems-1 {
+		t.Errorf("expected selected=%d, got %d", maxDisplayedItems-1, s.selected)
+	}
+
+	// Should not scroll when exactly at max
+	if s.scrollOffset != 0 {
+		t.Errorf("expected scrollOffset=0 for exactly maxDisplayedItems, got %d", s.scrollOffset)
+	}
+
+	// One more down should do nothing
+	s.handleInput(eventDown, 0)
+	if s.selected != maxDisplayedItems-1 {
+		t.Errorf("down at max: expected selected=%d, got %d", maxDisplayedItems-1, s.selected)
+	}
+}
+
+// TestFilterItems_RegexSpecialChars verifies that filter is literal, not regex.
+// User typing "model.v1" shouldn't match "modelsv1".
+func TestFilterItems_RegexSpecialChars(t *testing.T) {
+	items := []selectItem{
+		{Name: "model.v1"},
+		{Name: "modelsv1"},
+		{Name: "model-v1"},
+	}
+
+	// Filter with dot should only match literal dot
+	result := filterItems(items, "model.v1")
+	if len(result) != 1 {
+		t.Errorf("expected 1 exact match, got %d", len(result))
+	}
+	if len(result) > 0 && result[0].Name != "model.v1" {
+		t.Errorf("expected 'model.v1', got %s", result[0].Name)
+	}
+
+	// Other regex special chars should be literal too
+	items2 := []selectItem{
+		{Name: "test[0]"},
+		{Name: "test0"},
+		{Name: "test(1)"},
+	}
+
+	result2 := filterItems(items2, "test[0]")
+	if len(result2) != 1 || result2[0].Name != "test[0]" {
+		t.Errorf("expected only 'test[0]', got %v", result2)
+	}
+}
+
+// TestMultiSelectState_DuplicateNames documents handling of duplicate item names.
+// itemIndex uses name as key - duplicates cause collision. This documents
+// the current behavior: the last index for a duplicate name is stored
+func TestMultiSelectState_DuplicateNames(t *testing.T) {
+	// Duplicate names - this is an edge case that shouldn't happen in practice
+	items := []selectItem{
+		{Name: "duplicate"},
+		{Name: "duplicate"},
+		{Name: "unique"},
+	}
+
+	s := newMultiSelectState(items, nil)
+
+	// DOCUMENTED BEHAVIOR: itemIndex maps name to LAST index
+	// When there are duplicates, only the last occurrence's index is stored
+	if s.itemIndex["duplicate"] != 1 {
+		t.Errorf("itemIndex should map 'duplicate' to last index (1), got %d", s.itemIndex["duplicate"])
+	}
+
+	// Toggle item at highlighted=0 (first "duplicate")
+	// Due to name collision, toggleItem uses itemIndex["duplicate"] = 1
+	// So it actually toggles the SECOND duplicate item, not the first
+	s.toggleItem()
+
+	// This documents the potentially surprising behavior:
+	// We toggled at highlighted=0, but itemIndex lookup returned 1
+	if !s.checked[1] {
+		t.Error("toggle should check index 1 (due to name collision in itemIndex)")
+	}
+	if s.checked[0] {
+		t.Log("Note: index 0 is NOT checked, even though highlighted=0 (name collision behavior)")
+	}
+}
+
+// TestSelectState_FilterReducesBelowSelection verifies selection resets when filter reduces list.
+// Prevents index-out-of-bounds on next keystroke
+func TestSelectState_FilterReducesBelowSelection(t *testing.T) {
+	items := []selectItem{
+		{Name: "apple"},
+		{Name: "banana"},
+		{Name: "cherry"},
+	}
+
+	s := newSelectState(items)
+	s.selected = 2 // Select "cherry"
+
+	// Type a filter that removes cherry from results
+	s.handleInput(eventChar, 'a') // Filter to "a" - matches "apple" and "banana"
+
+	// Selection should reset to 0
+	if s.selected != 0 {
+		t.Errorf("expected selected=0 after filter, got %d", s.selected)
+	}
+
+	filtered := s.filtered()
+	if len(filtered) != 2 {
+		t.Errorf("expected 2 filtered items, got %d", len(filtered))
+	}
+}
+
+// TestFilterItems_UnicodeCharacters verifies filtering works with UTF-8.
+// Model names might contain unicode characters
+func TestFilterItems_UnicodeCharacters(t *testing.T) {
+	items := []selectItem{
+		{Name: "llama-日本語"},
+		{Name: "模型-chinese"},
+		{Name: "émoji-🦙"},
+		{Name: "regular-model"},
+	}
+
+	t.Run("filter japanese", func(t *testing.T) {
+		result := filterItems(items, "日本")
+		if len(result) != 1 || result[0].Name != "llama-日本語" {
+			t.Errorf("expected llama-日本語, got %v", result)
+		}
+	})
+
+	t.Run("filter chinese", func(t *testing.T) {
+		result := filterItems(items, "模型")
+		if len(result) != 1 || result[0].Name != "模型-chinese" {
+			t.Errorf("expected 模型-chinese, got %v", result)
+		}
+	})
+
+	t.Run("filter emoji", func(t *testing.T) {
+		result := filterItems(items, "🦙")
+		if len(result) != 1 || result[0].Name != "émoji-🦙" {
+			t.Errorf("expected émoji-🦙, got %v", result)
+		}
+	})
+
+	t.Run("filter accented char", func(t *testing.T) {
+		result := filterItems(items, "émoji")
+		if len(result) != 1 || result[0].Name != "émoji-🦙" {
+			t.Errorf("expected émoji-🦙, got %v", result)
+		}
+	})
+}
+
+// TestMultiSelectState_FilterReducesBelowHighlight verifies highlight resets when filter reduces list.
+func TestMultiSelectState_FilterReducesBelowHighlight(t *testing.T) {
+	items := []selectItem{
+		{Name: "apple"},
+		{Name: "banana"},
+		{Name: "cherry"},
+	}
+
+	s := newMultiSelectState(items, nil)
+	s.highlighted = 2 // Highlight "cherry"
+
+	// Type a filter that removes cherry
+	s.handleInput(eventChar, 'a')
+
+	if s.highlighted != 0 {
+		t.Errorf("expected highlighted=0 after filter, got %d", s.highlighted)
+	}
+}
+
+// TestMultiSelectState_EmptyItems verifies handling of empty item list.
+// Empty list should be handled gracefully.
+func TestMultiSelectState_EmptyItems(t *testing.T) {
+	s := newMultiSelectState([]selectItem{}, nil)
+
+	// Toggle should not panic on empty list
+	s.toggleItem()
+
+	if s.selectedCount() != 0 {
+		t.Errorf("expected 0 selected for empty list, got %d", s.selectedCount())
+	}
+
+	// Render should handle empty list
+	var buf bytes.Buffer
+	lineCount := renderMultiSelect(&buf, "Select:", s)
+	if lineCount == 0 {
+		t.Error("renderMultiSelect should produce output even for empty list")
+	}
+	if !strings.Contains(buf.String(), "no matches") {
+		t.Error("expected 'no matches' for empty list")
+	}
+}
+
+// TestSelectState_RenderWithDescriptions verifies rendering items with descriptions.
+func TestSelectState_RenderWithDescriptions(t *testing.T) {
+	items := []selectItem{
+		{Name: "item1", Description: "First item description"},
+		{Name: "item2", Description: ""},
+		{Name: "item3", Description: "Third item"},
+	}
+
+	s := newSelectState(items)
+	var buf bytes.Buffer
+	renderSelect(&buf, "Select:", s)
+
+	output := buf.String()
+	if !strings.Contains(output, "First item description") {
+		t.Error("expected description to be rendered")
+	}
+	if !strings.Contains(output, "item2") {
+		t.Error("expected item without description to be rendered")
+	}
+}

cmd/interactive.go

@@ -7,6 +7,7 @@ import (
 	"io"
 	"net/http"
 	"os"
+	"os/exec"
 	"path/filepath"
 	"regexp"
 	"slices"
@@ -79,6 +80,7 @@ func generateInteractive(cmd *cobra.Command, opts runOptions) error {
 		fmt.Fprintln(os.Stderr, "  Ctrl + w            Delete the word before the cursor")
 		fmt.Fprintln(os.Stderr, "")
 		fmt.Fprintln(os.Stderr, "  Ctrl + l            Clear the screen")
+		fmt.Fprintln(os.Stderr, "  Ctrl + g            Open default editor to compose a prompt")
 		fmt.Fprintln(os.Stderr, "  Ctrl + c            Stop the model from responding")
 		fmt.Fprintln(os.Stderr, "  Ctrl + d            Exit ollama (/bye)")
 		fmt.Fprintln(os.Stderr, "")
@@ -147,6 +149,18 @@ func generateInteractive(cmd *cobra.Command, opts runOptions) error {
 			scanner.Prompt.UseAlt = false
 			sb.Reset()
 
+			continue
+		case errors.Is(err, readline.ErrEditPrompt):
+			sb.Reset()
+			content, err := editInExternalEditor(line)
+			if err != nil {
+				fmt.Fprintf(os.Stderr, "error: %v\n", err)
+				continue
+			}
+			if strings.TrimSpace(content) == "" {
+				continue
+			}
+			scanner.Prefill = content
 			continue
 		case err != nil:
 			return err
@@ -598,6 +612,57 @@ func extractFileData(input string) (string, []api.ImageData, error) {
 	return strings.TrimSpace(input), imgs, nil
 }
 
+func editInExternalEditor(content string) (string, error) {
+	editor := envconfig.Editor()
+	if editor == "" {
+		editor = os.Getenv("VISUAL")
+	}
+	if editor == "" {
+		editor = os.Getenv("EDITOR")
+	}
+	if editor == "" {
+		editor = "vi"
+	}
+
+	// Check that the editor binary exists
+	name := strings.Fields(editor)[0]
+	if _, err := exec.LookPath(name); err != nil {
+		return "", fmt.Errorf("editor %q not found, set OLLAMA_EDITOR to the path of your preferred editor", name)
+	}
+
+	tmpFile, err := os.CreateTemp("", "ollama-prompt-*.txt")
+	if err != nil {
+		return "", fmt.Errorf("creating temp file: %w", err)
+	}
+	defer os.Remove(tmpFile.Name())
+
+	if content != "" {
+		if _, err := tmpFile.WriteString(content); err != nil {
+			tmpFile.Close()
+			return "", fmt.Errorf("writing to temp file: %w", err)
+		}
+	}
+	tmpFile.Close()
+
+	args := strings.Fields(editor)
+	args = append(args, tmpFile.Name())
+	cmd := exec.Command(args[0], args[1:]...)
+	cmd.Stdin = os.Stdin
+	cmd.Stdout = os.Stdout
+	cmd.Stderr = os.Stderr
+
+	if err := cmd.Run(); err != nil {
+		return "", fmt.Errorf("editor exited with error: %w", err)
+	}
+
+	data, err := os.ReadFile(tmpFile.Name())
+	if err != nil {
+		return "", fmt.Errorf("reading temp file: %w", err)
+	}
+
+	return strings.TrimRight(string(data), "\n"), nil
+}
+
 func getImageData(filePath string) ([]byte, error) {
 	file, err := os.Open(filePath)
 	if err != nil {

cmd/tui/confirm.go

@@ -1,109 +0,0 @@
-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

@@ -1,208 +0,0 @@
-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,44 +18,35 @@ var (
 
 	selectorSelectedItemStyle = lipgloss.NewStyle().
 					PaddingLeft(2).
-					Bold(true).
-					Background(lipgloss.AdaptiveColor{Light: "254", Dark: "236"})
+					Bold(true)
 
 	selectorDescStyle = lipgloss.NewStyle().
-				Foreground(lipgloss.AdaptiveColor{Light: "242", Dark: "246"})
-
-	selectorDescLineStyle = selectorDescStyle.
-				PaddingLeft(6)
+				Foreground(lipgloss.Color("241"))
 
 	selectorFilterStyle = lipgloss.NewStyle().
-				Foreground(lipgloss.AdaptiveColor{Light: "242", Dark: "246"}).
+				Foreground(lipgloss.Color("241")).
 				Italic(true)
 
 	selectorInputStyle = lipgloss.NewStyle().
-				Foreground(lipgloss.AdaptiveColor{Light: "235", Dark: "252"})
+				Foreground(lipgloss.Color("252"))
 
 	selectorCheckboxStyle = lipgloss.NewStyle().
-				Foreground(lipgloss.AdaptiveColor{Light: "242", Dark: "246"})
+				Foreground(lipgloss.Color("241"))
 
 	selectorCheckboxCheckedStyle = lipgloss.NewStyle().
 					Bold(true)
 
 	selectorDefaultTagStyle = lipgloss.NewStyle().
-				Foreground(lipgloss.AdaptiveColor{Light: "242", Dark: "246"}).
+				Foreground(lipgloss.Color("241")).
 				Italic(true)
 
 	selectorHelpStyle = lipgloss.NewStyle().
-				Foreground(lipgloss.AdaptiveColor{Light: "244", Dark: "244"})
+				Foreground(lipgloss.Color("241"))
 
 	selectorMoreStyle = lipgloss.NewStyle().
-				PaddingLeft(6).
-				Foreground(lipgloss.AdaptiveColor{Light: "242", Dark: "246"}).
+				PaddingLeft(4).
+				Foreground(lipgloss.Color("241")).
 				Italic(true)
-
-	sectionHeaderStyle = lipgloss.NewStyle().
-				PaddingLeft(2).
-				Bold(true).
-				Foreground(lipgloss.AdaptiveColor{Light: "240", Dark: "249"})
 )
 
 const maxSelectorItems = 10
@@ -63,10 +54,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.
@@ -78,8 +69,6 @@ type selectorModel struct {
 	scrollOffset int
 	selected     string
 	cancelled    bool
-	helpText     string
-	width        int
 }
 
 func (m selectorModel) filteredItems() []SelectItem {
@@ -100,153 +89,83 @@ 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.WindowSizeMsg:
-		wasSet := m.width > 0
-		m.width = msg.Width
-		if wasSet {
-			return m, tea.EnterAltScreen
-		}
-		return m, nil
-
 	case tea.KeyMsg:
+		filtered := m.filteredItems()
+
 		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
 
-		default:
-			m.updateNavigation(msg)
+		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
 		}
 	}
 
 	return m, nil
 }
 
-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))
+func (m selectorModel) View() string {
+	// Clear screen when exiting
+	if m.cancelled || m.selected != "" {
+		return ""
 	}
-	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 == "" {
@@ -261,91 +180,42 @@ func (m selectorModel) renderContent() string {
 	if len(filtered) == 0 {
 		s.WriteString(selectorItemStyle.Render(selectorDescStyle.Render("(no matches)")))
 		s.WriteString("\n")
-	} else if m.filter != "" {
-		s.WriteString(sectionHeaderStyle.Render("Top Results"))
-		s.WriteString("\n")
-
+	} else {
 		displayCount := min(len(filtered), maxSelectorItems)
+
 		for i := range displayCount {
 			idx := m.scrollOffset + i
 			if idx >= len(filtered) {
 				break
 			}
-			m.renderItem(&s, filtered[idx], idx)
+			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")
 		}
 
 		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")
-	help := "↑/↓ navigate • enter select • esc cancel"
-	if m.helpText != "" {
-		help = m.helpText
-	}
-	s.WriteString(selectorHelpStyle.Render(help))
+	s.WriteString(selectorHelpStyle.Render("↑/↓ navigate • enter select • esc cancel"))
 
 	return s.String()
 }
 
-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
-}
-
+// SelectSingle prompts the user to select a single item from a list.
 func SelectSingle(title string, items []SelectItem) (string, error) {
 	if len(items) == 0 {
 		return "", fmt.Errorf("no items to select from")
@@ -382,7 +252,6 @@ type multiSelectorModel struct {
 	checkOrder   []int
 	cancelled    bool
 	confirmed    bool
-	width        int
 }
 
 func newMultiSelectorModel(title string, items []SelectItem, preChecked []string) multiSelectorModel {
@@ -454,14 +323,6 @@ 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()
 
@@ -471,12 +332,14 @@ 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:
@@ -532,12 +395,14 @@ 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 == "" {
@@ -554,8 +419,6 @@ 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
@@ -565,17 +428,7 @@ func (m multiSelectorModel) View() string {
 			item := filtered[idx]
 			origIdx := m.itemIndex[item.Name]
 
-			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
-			}
-
+			// Checkbox
 			var checkbox string
 			if m.checked[origIdx] {
 				checkbox = selectorCheckboxCheckedStyle.Render("[x]")
@@ -583,6 +436,7 @@ 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)
@@ -590,6 +444,7 @@ func (m multiSelectorModel) View() string {
 				line = "  " + checkbox + " " + item.Name
 			}
 
+			// Default tag
 			if len(m.checkOrder) > 0 && m.checkOrder[0] == origIdx {
 				line += " " + selectorDefaultTagStyle.Render("(default)")
 			}
@@ -606,6 +461,7 @@ 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."))
@@ -616,13 +472,10 @@ func (m multiSelectorModel) View() string {
 
 	s.WriteString(selectorHelpStyle.Render("↑/↓ navigate • space toggle • enter confirm • esc cancel"))
 
-	result := s.String()
-	if m.width > 0 {
-		return lipgloss.NewStyle().MaxWidth(m.width).Render(result)
-	}
-	return result
+	return s.String()
 }
 
+// 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

@@ -1,410 +0,0 @@
-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

@@ -1,128 +0,0 @@
-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

@@ -1,175 +0,0 @@
-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,6 +4,8 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"os/exec"
+	"runtime"
 	"strings"
 	"time"
 
@@ -15,30 +17,37 @@ import (
 )
 
 var (
-	versionStyle = lipgloss.NewStyle().
-			Foreground(lipgloss.AdaptiveColor{Light: "243", Dark: "250"})
+	titleStyle = lipgloss.NewStyle().
+			Bold(true).
+			MarginBottom(1)
 
-	menuItemStyle = lipgloss.NewStyle().
+	versionStyle = lipgloss.NewStyle().
+			Foreground(lipgloss.Color("245"))
+
+	itemStyle = lipgloss.NewStyle().
 			PaddingLeft(2)
 
-	menuSelectedItemStyle = lipgloss.NewStyle().
-				Bold(true).
-				Background(lipgloss.AdaptiveColor{Light: "254", Dark: "236"})
+	selectedStyle = lipgloss.NewStyle().
+			PaddingLeft(2).
+			Bold(true)
 
-	menuDescStyle = selectorDescStyle.
-			PaddingLeft(4)
+	greyedStyle = lipgloss.NewStyle().
+			PaddingLeft(2).
+			Foreground(lipgloss.Color("241"))
 
-	greyedStyle = menuItemStyle.
-			Foreground(lipgloss.AdaptiveColor{Light: "242", Dark: "246"})
+	greyedSelectedStyle = lipgloss.NewStyle().
+				PaddingLeft(2).
+				Foreground(lipgloss.Color("243"))
 
-	greyedSelectedStyle = menuSelectedItemStyle.
-				Foreground(lipgloss.AdaptiveColor{Light: "242", Dark: "246"})
+	descStyle = lipgloss.NewStyle().
+			PaddingLeft(4).
+			Foreground(lipgloss.Color("241"))
 
 	modelStyle = lipgloss.NewStyle().
-			Foreground(lipgloss.AdaptiveColor{Light: "243", Dark: "250"})
+			Foreground(lipgloss.Color("245"))
 
 	notInstalledStyle = lipgloss.NewStyle().
-				Foreground(lipgloss.AdaptiveColor{Light: "242", Dark: "246"}).
+				Foreground(lipgloss.Color("241")).
 				Italic(true)
 )
 
@@ -46,102 +55,94 @@ type menuItem struct {
 	title       string
 	description string
 	integration string // integration name for loading model config, empty if not an integration
-	isRunModel  bool
-	isOthers    bool
+	isRunModel  bool   // true for the "Run a model" option
+	isOthers    bool   // true for the "Others..." toggle item
 }
 
 var mainMenuItems = []menuItem{
 	{
 		title:       "Run a model",
-		description: "Start an interactive chat with a model",
+		description: "Start an interactive chat with a local model",
 		isRunModel:  true,
 	},
 	{
 		title:       "Launch Claude Code",
-		description: "Agentic coding across large codebases",
+		description: "Open Claude Code AI assistant",
 		integration: "claude",
 	},
 	{
 		title:       "Launch Codex",
-		description: "OpenAI's open-source coding agent",
+		description: "Open Codex CLI",
 		integration: "codex",
 	},
 	{
-		title:       "Launch OpenClaw",
-		description: "Personal AI with 100+ skills",
+		title:       "Launch Open Claw",
+		description: "Open the Open Claw integration",
 		integration: "openclaw",
 	},
 }
 
 var othersMenuItem = menuItem{
-	title:       "More...",
+	title:       "Others...",
 	description: "Show additional integrations",
 	isOthers:    true,
 }
 
-// getOtherIntegrations dynamically builds the "Others" list from the integration
-// registry, excluding any integrations already present in the pinned mainMenuItems.
+// getOtherIntegrations returns the list of other integrations, filtering out
+// Codex if it's not installed (since it requires npm install).
 func getOtherIntegrations() []menuItem {
-	pinned := map[string]bool{
-		"run": true, // not an integration but in the pinned list
+	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",
+		},
 	}
-	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
-	changeModel     bool
-	showOthers      bool
-	availableModels map[string]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
 	err             error
 
-	showingModal  bool
-	modalSelector selectorModel
-	modalItems    []SelectItem
+	// 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
 
-	showingSignIn   bool
-	signInURL       string
-	signInModel     string
-	signInSpinner   int
+	// 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
 	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
 }
 
-type clearStatusMsg struct{}
-
+// modelExists checks if a model exists in the cached available models.
 func (m *model) modelExists(name string) bool {
 	if m.availableModels == nil || name == "" {
 		return false
@@ -158,25 +159,27 @@ 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, Recommended: item.Recommended})
+		items = append(items, SelectItem{Name: item.Name, Description: item.Description})
 	}
 	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,
-		helpText: "↑/↓ navigate • enter select • ← back",
+		title: "Select model:",
+		items: m.modalItems,
 	}
 	m.showingModal = true
 }
 
+// isCloudModel returns true if the model name indicates a cloud model.
 func isCloudModel(name string) bool {
 	return strings.HasSuffix(name, ":cloud")
 }
@@ -193,7 +196,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
+		return nil // Already signed in
 	}
 	var aErr api.AuthorizationError
 	if errors.As(err, &aErr) && aErr.SigninURL != "" {
@@ -212,13 +215,23 @@ func (m *model) startSignIn(modelName, signInURL string, fromModal bool) tea.Cmd
 	m.signInSpinner = 0
 	m.signInFromModal = fromModal
 
-	config.OpenBrowser(signInURL)
+	// 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()
+	}
 
+	// 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 {
@@ -231,6 +244,7 @@ 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()
@@ -252,17 +266,24 @@ 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 {
-	for _, item := range getOtherIntegrations() {
-		if item.integration == name {
-			return true
-		}
+	switch name {
+	case "droid", "opencode":
+		return true
 	}
 	return false
 }
@@ -273,6 +294,7 @@ 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
@@ -280,6 +302,7 @@ func initialModel() model {
 
 	m.buildItems()
 
+	// Position cursor on last selection
 	if lastSelection != "" {
 		for i, item := range m.items {
 			if lastSelection == "run" && item.isRunModel {
@@ -300,29 +323,18 @@ func (m model) Init() tea.Cmd {
 }
 
 func (m model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
-	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
-	}
-
+	// Handle sign-in dialog
 	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
 			}
 
@@ -343,10 +355,13 @@ 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
@@ -356,11 +371,13 @@ 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, tea.KeyLeft:
+			case tea.KeyCtrlC, tea.KeyEsc:
+				// Close modal without selection
 				m.showingModal = false
 				return m, nil
 
@@ -373,15 +390,63 @@ 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
 
-			default:
-				// Delegate navigation (up/down/pgup/pgdown/filter/backspace) to selectorModel
-				m.modalSelector.updateNavigation(msg)
+			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
 			}
 		}
 		return m, nil
@@ -398,30 +463,32 @@ 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()
@@ -437,8 +504,10 @@ 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
 				}
@@ -455,19 +524,21 @@ 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 := selectorTitleStyle.Render("Ollama "+versionStyle.Render(version.Version)) + "\n\n"
+	s := titleStyle.Render("  Ollama "+versionStyle.Render("v"+version.Version)) + "\n\n"
 
 	for i, item := range m.items {
-		cursor := ""
-		style := menuItemStyle
+		cursor := "  "
+		style := itemStyle
 		isInstalled := true
 
 		if item.integration != "" {
@@ -477,7 +548,7 @@ func (m model) View() string {
 		if m.cursor == i {
 			cursor = "▸ "
 			if isInstalled {
-				style = menuSelectedItemStyle
+				style = selectedStyle
 			} else {
 				style = greyedSelectedStyle
 			}
@@ -486,62 +557,119 @@ func (m model) View() string {
 		}
 
 		title := item.title
-		var modelSuffix string
 		if item.integration != "" {
 			if !isInstalled {
 				title += " " + notInstalledStyle.Render("(not installed)")
-			} else if m.cursor == i {
-				if mdl := config.IntegrationModel(item.integration); mdl != "" && m.modelExists(mdl) {
-					modelSuffix = " " + modelStyle.Render("("+mdl+")")
-				}
+			} else if mdl := config.IntegrationModel(item.integration); mdl != "" && m.modelExists(mdl) {
+				title += " " + modelStyle.Render("("+mdl+")")
 			}
-		} else if item.isRunModel && m.cursor == i {
+		} else if item.isRunModel {
 			if mdl := config.LastModel(); mdl != "" && m.modelExists(mdl) {
-				modelSuffix = " " + modelStyle.Render("("+mdl+")")
+				title += " " + modelStyle.Render("("+mdl+")")
 			}
 		}
 
-		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 += style.Render(cursor+title) + "\n"
+		s += descStyle.Render(item.description) + "\n\n"
 	}
 
-	if m.statusMsg != "" {
-		s += "\n" + lipgloss.NewStyle().Foreground(lipgloss.AdaptiveColor{Light: "124", Dark: "210"}).Render(m.statusMsg) + "\n"
-	}
+	s += "\n" + lipgloss.NewStyle().Foreground(lipgloss.Color("241")).Render("↑/↓ navigate • enter select • → change model • esc quit")
 
-	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().
-		PaddingBottom(1).
-		PaddingRight(2)
+		Border(lipgloss.RoundedBorder()).
+		BorderForeground(lipgloss.Color("245")).
+		Padding(1, 2).
+		MarginLeft(2)
 
-	s := modalStyle.Render(m.modalSelector.renderContent())
-	if m.width > 0 {
-		return lipgloss.NewStyle().MaxWidth(m.width).Render(s)
+	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))
 	}
-	return 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())
 }
 
+// renderSignInDialog renders the sign-in dialog.
 func (m model) renderSignInDialog() string {
-	return renderSignIn(m.signInModel, m.signInURL, m.signInSpinner, m.width)
+	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())
 }
 
+// Selection represents what the user selected
 type Selection int
 
 const (
@@ -552,12 +680,14 @@ 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)
@@ -572,12 +702,14 @@ 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{
@@ -592,6 +724,7 @@ func Run() (Result, error) {
 		}, nil
 	}
 
+	// Handle selection
 	if item.isRunModel {
 		return Result{Selection: SelectionRunModel}, nil
 	}

docs/context-length.mdx

@@ -5,10 +5,7 @@ title: Context length
 Context length is the maximum number of tokens that the model has access to in memory.  
 
 <Note>
-  Ollama defaults to the following context lengths based on VRAM:
-    - < 24 GiB VRAM: 4k context
-    - 24-48 GiB VRAM: 32k context
-    - &gt;= 48 GiB VRAM: 256k context
+  The default context length in Ollama is 4096 tokens.
 </Note>
 
 Tasks which require large context like web search, agents, and coding tools should be set to at least 64000 tokens.

envconfig/config.go

@@ -216,6 +216,7 @@ func String(s string) func() string {
 
 var (
 	LLMLibrary = String("OLLAMA_LLM_LIBRARY")
+	Editor     = String("OLLAMA_EDITOR")
 
 	CudaVisibleDevices    = String("CUDA_VISIBLE_DEVICES")
 	HipVisibleDevices     = String("HIP_VISIBLE_DEVICES")
@@ -291,6 +292,7 @@ func AsMap() map[string]EnvVar {
 		"OLLAMA_SCHED_SPREAD":      {"OLLAMA_SCHED_SPREAD", SchedSpread(), "Always schedule model across all GPUs"},
 		"OLLAMA_MULTIUSER_CACHE":   {"OLLAMA_MULTIUSER_CACHE", MultiUserCache(), "Optimize prompt caching for multi-user scenarios"},
 		"OLLAMA_CONTEXT_LENGTH":    {"OLLAMA_CONTEXT_LENGTH", ContextLength(), "Context length to use unless otherwise specified (default: 4k/32k/256k based on VRAM)"},
+		"OLLAMA_EDITOR":            {"OLLAMA_EDITOR", Editor(), "Path to editor for interactive prompt editing (Ctrl+G)"},
 		"OLLAMA_NEW_ENGINE":        {"OLLAMA_NEW_ENGINE", NewEngine(), "Enable the new Ollama engine"},
 		"OLLAMA_REMOTES":           {"OLLAMA_REMOTES", Remotes(), "Allowed hosts for remote models (default \"ollama.com\")"},
 

readline/errors.go

@@ -5,6 +5,7 @@ import (
 )
 
 var ErrInterrupt = errors.New("Interrupt")
+var ErrEditPrompt = errors.New("EditPrompt")
 
 type InterruptError struct {
 	Line []rune

readline/readline.go

@@ -41,6 +41,7 @@ type Instance struct {
 	Terminal    *Terminal
 	History     *History
 	Pasting     bool
+	Prefill     string
 	pastedLines []string
 }
 
@@ -89,6 +90,26 @@ func (i *Instance) Readline() (string, error) {
 
 	buf, _ := NewBuffer(i.Prompt)
 
+	if i.Prefill != "" {
+		lines := strings.Split(i.Prefill, "\n")
+		i.Prefill = ""
+		for idx, l := range lines {
+			for _, r := range l {
+				buf.Add(r)
+			}
+			if idx < len(lines)-1 {
+				i.pastedLines = append(i.pastedLines, buf.String())
+				buf.Buf.Clear()
+				buf.Pos = 0
+				buf.DisplayPos = 0
+				buf.LineHasSpace.Clear()
+				fmt.Println()
+				fmt.Print(i.Prompt.AltPrompt)
+				i.Prompt.UseAlt = true
+			}
+		}
+	}
+
 	var esc bool
 	var escex bool
 	var metaDel bool
@@ -251,6 +272,29 @@ func (i *Instance) Readline() (string, error) {
 			buf.ClearScreen()
 		case CharCtrlW:
 			buf.DeleteWord()
+		case CharBell:
+			output := buf.String()
+			numPastedLines := len(i.pastedLines)
+			if numPastedLines > 0 {
+				output = strings.Join(i.pastedLines, "\n") + "\n" + output
+				i.pastedLines = nil
+			}
+
+			// Move cursor to the last display line of the current buffer
+			currLine := buf.DisplayPos / buf.LineWidth
+			lastLine := buf.DisplaySize() / buf.LineWidth
+			if lastLine > currLine {
+				fmt.Print(CursorDownN(lastLine - currLine))
+			}
+
+			// Clear all lines from bottom to top: buffer wrapped lines + pasted lines
+			for range lastLine + numPastedLines {
+				fmt.Print(CursorBOL + ClearToEOL + CursorUp)
+			}
+			fmt.Print(CursorBOL + ClearToEOL)
+
+			i.Prompt.UseAlt = false
+			return output, ErrEditPrompt
 		case CharCtrlZ:
 			fd := os.Stdin.Fd()
 			return handleCharCtrlZ(fd, i.Terminal.termios)