Add richer sah run UX

Author: akcorca

cmd/sah/main.go

@@ -71,8 +71,9 @@ Commands:
 
 Examples:
   sah auth login
-  sah run --agent codex
-  sah daemon install --agent claude --interval 30m
+  sah run --rotate-installed
+  sah run --agents codex,gemini,claude --models codex=gpt-5.4-mini,gemini=gemini3-flash,claude=sonnet
+  sah daemon install --agents codex,claude --interval 30m
   sah me
 `)
 }
@@ -169,7 +170,10 @@ func runCmd(args []string) error {
 	fs := flag.NewFlagSet("run", flag.ContinueOnError)
 	fs.SetOutput(os.Stderr)
 	agent := fs.String("agent", "", "Agent CLI to use: codex, gemini, claude")
+	agents := fs.String("agents", "", "Comma-separated round-robin agent order, e.g. codex,gemini,claude")
+	rotateInstalled := fs.Bool("rotate-installed", false, "Rotate through every supported agent CLI installed on this Mac")
 	model := fs.String("model", "", "Optional model override passed to the agent CLI")
+	models := fs.String("models", "", "Per-agent model overrides, e.g. codex=gpt-5.4-mini,gemini=gemini3-flash,claude=sonnet")
 	interval := fs.String("interval", "", "Polling interval")
 	timeout := fs.String("timeout", "", "Per-assignment agent timeout")
 	taskType := fs.String("task-type", "", "Optional task type filter")
@@ -179,6 +183,12 @@ func runCmd(args []string) error {
 	if err := fs.Parse(args); err != nil {
 		return err
 	}
+	if err := validateAgentFlags(*agent, *agents, *rotateInstalled); err != nil {
+		return err
+	}
+	if !*daemonMode {
+		sah.PrintRunBanner(os.Stdout)
+	}
 
 	ctx, cancel := signalContext()
 	defer cancel()
@@ -205,6 +215,16 @@ func runCmd(args []string) error {
 			return err
 		}
 	}
+	agentPool := sah.ParseAgentList(*agents)
+	if len(agentPool) > 0 {
+		if _, err := sah.ResolveAgentPool(config, sah.WorkerOptions{Agents: agentPool}); err != nil {
+			return err
+		}
+	}
+	agentModels, err := sah.ParseAgentModels(*models)
+	if err != nil {
+		return err
+	}
 
 	pollInterval, err := sah.ParsePollInterval(pickString(*interval, config.PollInterval))
 	if err != nil {
@@ -215,16 +235,29 @@ func runCmd(args []string) error {
 		return err
 	}
 
-	return sah.RunWorker(ctx, config, sah.WorkerOptions{
-		Agent:       pickString(*agent, config.DefaultAgent),
-		Model:       pickString(*model, config.AgentModel),
-		Interval:    pollInterval,
-		Timeout:     agentTimeout,
-		TaskType:    strings.TrimSpace(*taskType),
-		Once:        *once,
-		Output:      os.Stdout,
-		ErrorOutput: os.Stderr,
-	})
+	options := sah.WorkerOptions{
+		Agent:           pickString(*agent, config.DefaultAgent),
+		Agents:          agentPool,
+		RotateInstalled: *rotateInstalled,
+		Model:           pickString(*model, config.AgentModel),
+		Models:          sah.MergeAgentModels(config.AgentModels, agentModels),
+		Interval:        pollInterval,
+		Timeout:         agentTimeout,
+		TaskType:        strings.TrimSpace(*taskType),
+		Once:            *once,
+		Output:          os.Stdout,
+		ErrorOutput:     os.Stderr,
+	}
+
+	picker, err := sah.NewAgentPicker(config, options)
+	if err != nil {
+		return err
+	}
+	if !*daemonMode {
+		sah.PrintRunPlan(os.Stdout, config, options, picker.Pool())
+	}
+
+	return sah.RunWorker(ctx, config, options)
 }
 
 func daemonCmd(args []string) error {
@@ -237,13 +270,19 @@ func daemonCmd(args []string) error {
 		fs := flag.NewFlagSet("daemon install", flag.ContinueOnError)
 		fs.SetOutput(os.Stderr)
 		agent := fs.String("agent", "", "Default agent CLI for the daemon")
+		agents := fs.String("agents", "", "Comma-separated round-robin agent order for the daemon")
+		rotateInstalled := fs.Bool("rotate-installed", false, "Rotate through every installed supported agent CLI")
 		model := fs.String("model", "", "Default model override")
+		models := fs.String("models", "", "Per-agent model overrides, e.g. codex=gpt-5.4-mini,gemini=gemini3-flash,claude=sonnet")
 		interval := fs.String("interval", "", "Default polling interval")
 		timeout := fs.String("timeout", "", "Default per-assignment timeout")
 		baseURL := fs.String("base-url", "", "SCIENCE@home base URL")
 		if err := fs.Parse(args[1:]); err != nil {
 			return err
 		}
+		if err := validateAgentFlags(*agent, *agents, *rotateInstalled); err != nil {
+			return err
+		}
 
 		ctx, cancel := signalContext()
 		defer cancel()
@@ -260,10 +299,31 @@ func daemonCmd(args []string) error {
 				return err
 			}
 			config.DefaultAgent = *agent
+			config.AgentPool = nil
+			config.RotateInstalled = false
+		}
+		if pool := sah.ParseAgentList(*agents); len(pool) > 0 {
+			if _, err := sah.ResolveAgentPool(config, sah.WorkerOptions{Agents: pool}); err != nil {
+				return err
+			}
+			config.AgentPool = pool
+			config.RotateInstalled = false
+		}
+		if *rotateInstalled {
+			if _, err := sah.ResolveAgentPool(config, sah.WorkerOptions{RotateInstalled: true}); err != nil {
+				return err
+			}
+			config.AgentPool = nil
+			config.RotateInstalled = true
 		}
 		if strings.TrimSpace(*model) != "" {
 			config.AgentModel = *model
 		}
+		if parsedModels, err := sah.ParseAgentModels(*models); err != nil {
+			return err
+		} else if parsedModels != nil {
+			config.AgentModels = parsedModels
+		}
 		if strings.TrimSpace(*interval) != "" {
 			if _, err := sah.ParsePollInterval(*interval); err != nil {
 				return err
@@ -342,7 +402,13 @@ func daemonCmd(args []string) error {
 			return err
 		}
 		fmt.Printf("Base URL: %s\n", config.BaseURL)
-		fmt.Printf("Default agent: %s\n", config.DefaultAgent)
+		fmt.Printf("Agents: %s\n", sah.DescribeAgentMode(config, sah.WorkerOptions{}))
+		if model := strings.TrimSpace(config.AgentModel); model != "" {
+			fmt.Printf("Model: %s\n", model)
+		}
+		if models := sah.FormatAgentModels(config.AgentModels); models != "" {
+			fmt.Printf("Per-agent models: %s\n", models)
+		}
 		fmt.Printf("Interval: %s\n", config.PollInterval)
 		if loaded {
 			fmt.Println("Launchd: loaded")
@@ -492,13 +558,13 @@ func agentsCmd(args []string) error {
 	}
 
 	writer := tabwriter.NewWriter(os.Stdout, 0, 0, 2, ' ', 0)
-	fmt.Fprintln(writer, "NAME\tINSTALLED\tPATH\tDESCRIPTION")
+	fmt.Fprintln(writer, "NAME\tINSTALLED\tPATH\tDESCRIPTION\tMODEL FLAG")
 	for _, status := range sah.InstalledAgents() {
 		installed := "no"
 		if status.Installed {
 			installed = "yes"
 		}
-		fmt.Fprintf(writer, "%s\t%s\t%s\t%s\n", status.Name, installed, status.Path, status.Description)
+		fmt.Fprintf(writer, "%s\t%s\t%s\t%s\t--model / --models %s=<name>\n", status.Name, installed, status.Path, status.Description, status.Name)
 	}
 	return writer.Flush()
 }
@@ -587,6 +653,16 @@ func pickString(primary string, fallback string) string {
 	return fallback
 }
 
+func validateAgentFlags(agent string, agents string, rotateInstalled bool) error {
+	if rotateInstalled && (strings.TrimSpace(agent) != "" || strings.TrimSpace(agents) != "") {
+		return fmt.Errorf("--rotate-installed cannot be combined with --agent or --agents")
+	}
+	if strings.TrimSpace(agent) != "" && strings.TrimSpace(agents) != "" {
+		return fmt.Errorf("--agent cannot be combined with --agents")
+	}
+	return nil
+}
+
 func signalContext() (context.Context, context.CancelFunc) {
 	return signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
 }

internal/sah/agent_selection.go

@@ -0,0 +1,185 @@
+package sah
+
+import (
+	"fmt"
+	"sort"
+	"strings"
+)
+
+type AgentPicker struct {
+	pool  []AgentSpec
+	index int
+}
+
+func NewAgentPicker(config Config, options WorkerOptions) (*AgentPicker, error) {
+	pool, err := ResolveAgentPool(config, options)
+	if err != nil {
+		return nil, err
+	}
+	return &AgentPicker{pool: pool}, nil
+}
+
+func (picker *AgentPicker) Pool() []AgentSpec {
+	cloned := make([]AgentSpec, len(picker.pool))
+	copy(cloned, picker.pool)
+	return cloned
+}
+
+func (picker *AgentPicker) Next() AgentSpec {
+	agent := picker.pool[picker.index%len(picker.pool)]
+	picker.index++
+	return agent
+}
+
+func ResolveAgentPool(config Config, options WorkerOptions) ([]AgentSpec, error) {
+	switch {
+	case options.RotateInstalled:
+		return resolveInstalledAgentPool()
+	case len(options.Agents) > 0:
+		return resolveNamedAgentPool(options.Agents)
+	case config.RotateInstalled:
+		return resolveInstalledAgentPool()
+	case len(config.AgentPool) > 0:
+		return resolveNamedAgentPool(config.AgentPool)
+	default:
+		name := strings.TrimSpace(options.Agent)
+		if name == "" {
+			name = config.DefaultAgent
+		}
+		agent, err := ResolveAgent(name)
+		if err != nil {
+			return nil, err
+		}
+		return []AgentSpec{agent}, nil
+	}
+}
+
+func resolveInstalledAgentPool() ([]AgentSpec, error) {
+	pool := make([]AgentSpec, 0, len(SupportedAgents))
+	for _, status := range InstalledAgents() {
+		if status.Installed {
+			pool = append(pool, status.AgentSpec)
+		}
+	}
+	if len(pool) == 0 {
+		return nil, fmt.Errorf("no supported agent CLI found in PATH")
+	}
+	return pool, nil
+}
+
+func resolveNamedAgentPool(names []string) ([]AgentSpec, error) {
+	pool := make([]AgentSpec, 0, len(names))
+	seen := map[string]struct{}{}
+	for _, entry := range names {
+		name := normalizeAgentName(entry)
+		if name == "" {
+			continue
+		}
+		if _, ok := seen[name]; ok {
+			continue
+		}
+		agent, err := ResolveAgent(name)
+		if err != nil {
+			return nil, err
+		}
+		seen[name] = struct{}{}
+		pool = append(pool, agent)
+	}
+	if len(pool) == 0 {
+		return nil, fmt.Errorf("agent pool is empty")
+	}
+	return pool, nil
+}
+
+func ParseAgentList(raw string) []string {
+	if strings.TrimSpace(raw) == "" {
+		return nil
+	}
+
+	return normalizeAgentPool(strings.Split(raw, ","))
+}
+
+func ParseAgentModels(raw string) (map[string]string, error) {
+	if strings.TrimSpace(raw) == "" {
+		return nil, nil
+	}
+
+	models := map[string]string{}
+	for _, entry := range strings.Split(raw, ",") {
+		pair := strings.SplitN(strings.TrimSpace(entry), "=", 2)
+		if len(pair) != 2 {
+			return nil, fmt.Errorf("invalid model override %q; expected agent=model", entry)
+		}
+
+		name := normalizeAgentName(pair[0])
+		model := strings.TrimSpace(pair[1])
+		if name == "" || model == "" {
+			return nil, fmt.Errorf("invalid model override %q; expected agent=model", entry)
+		}
+		models[name] = model
+	}
+	return normalizeAgentModels(models), nil
+}
+
+func MergeAgentModels(base map[string]string, overrides map[string]string) map[string]string {
+	if len(base) == 0 && len(overrides) == 0 {
+		return nil
+	}
+
+	merged := map[string]string{}
+	for name, model := range normalizeAgentModels(base) {
+		merged[name] = model
+	}
+	for name, model := range normalizeAgentModels(overrides) {
+		merged[name] = model
+	}
+	if len(merged) == 0 {
+		return nil
+	}
+	return merged
+}
+
+func ModelForAgent(agentName string, fallback string, overrides map[string]string) string {
+	if model, ok := normalizeAgentModels(overrides)[normalizeAgentName(agentName)]; ok {
+		return model
+	}
+	return strings.TrimSpace(fallback)
+}
+
+func DescribeAgentMode(config Config, options WorkerOptions) string {
+	if options.RotateInstalled {
+		return "all installed agents"
+	}
+	if len(options.Agents) > 0 {
+		return strings.Join(options.Agents, ", ")
+	}
+	if config.RotateInstalled {
+		return "all installed agents"
+	}
+	if len(config.AgentPool) > 0 {
+		return strings.Join(config.AgentPool, ", ")
+	}
+	if strings.TrimSpace(options.Agent) != "" {
+		return normalizeAgentName(options.Agent)
+	}
+	return config.DefaultAgent
+}
+
+func FormatAgentModels(models map[string]string) string {
+	normalized := normalizeAgentModels(models)
+	if len(normalized) == 0 {
+		return ""
+	}
+
+	names := make([]string, 0, len(normalized))
+	for name := range normalized {
+		names = append(names, name)
+	}
+	sort.Strings(names)
+
+	parts := make([]string, 0, len(names))
+	for _, name := range names {
+		parts = append(parts, fmt.Sprintf("%s=%s", name, normalized[name]))
+	}
+	return strings.Join(parts, ", ")
+}