feat: support multiple job IDs in roborev wait (#377)

## Summary
- Extend `roborev wait` to accept multiple job IDs/refs, waiting for all
concurrently
- `roborev wait --job 251 252 253` or `roborev wait 251 252 253` now
works
- Exit code 1 if any job fails; 0 only if all pass
- Goroutines poll in quiet mode to avoid interleaved output

## Test plan
- [x] `TestWaitMultipleJobIDs` — all jobs pass, expect exit 0
- [x] `TestWaitMultipleJobIDsOneFails` — one fails, expect exit 1
- [x] `TestWaitMultipleJobIDsValidation` — `--sha` incompatible with
multiple args
- [x] All 52 existing wait tests still pass
- [x] Full suite (3503 tests) passes

🤖 Generated with [Claude Code](https://claude.com/claude-code)

---------

Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>
Co-authored-by: Wes McKinney <wesmckinn+git@gmail.com>

Author: 3 people

cmd/roborev/wait.go

@@ -4,6 +4,7 @@ import (
 	"errors"
 	"fmt"
 	"strconv"
+	"sync"
 
 	"github.com/roborev-dev/roborev/internal/git"
 	"github.com/spf13/cobra"
@@ -17,7 +18,7 @@ func waitCmd() *cobra.Command {
 	)
 
 	cmd := &cobra.Command{
-		Use:   "wait [job_id|sha]",
+		Use:   "wait [job_id|sha ...]",
 		Short: "Wait for an existing review job to complete",
 		Long: `Wait for an already-running review job to complete, without enqueuing a new one.
 
@@ -29,17 +30,21 @@ calls wait to block until the result is ready.
 The argument can be a job ID (numeric) or a git ref (commit SHA, branch, HEAD).
 If no argument is given, defaults to HEAD.
 
+Multiple arguments can be given to wait for several jobs concurrently.
+With --job, all arguments are treated as job IDs.
+
 Exit codes:
-  0  Review completed with verdict PASS
+  0  All reviews completed with verdict PASS
   1  Any failure (FAIL verdict, no job found, job error)
 
 Examples:
   roborev wait                   # Wait for most recent job for HEAD
   roborev wait abc123            # Wait for most recent job for commit
   roborev wait 42                # Job ID (if "42" is not a valid git ref)
   roborev wait --job 42          # Force as job ID
+  roborev wait --job 10 20 30    # Wait for multiple job IDs
   roborev wait --sha HEAD~1      # Wait for job matching HEAD~1`,
-		Args: cobra.MaximumNArgs(1),
+		Args: cobra.ArbitraryArgs,
 		RunE: func(cmd *cobra.Command, args []string) error {
 			// In quiet mode, suppress cobra's error output
 			if quiet {
@@ -55,6 +60,11 @@ Examples:
 				return fmt.Errorf("--job requires a job ID argument")
 			}
 
+			// Multiple args: wait for all concurrently
+			if len(args) > 1 {
+				return waitMultiple(cmd, args, forceJobID, quiet)
+			}
+
 			// Resolve the target to a job ID (local validation first,
 			// daemon contact deferred until actually needed)
 			var jobID int64
@@ -151,8 +161,145 @@ Examples:
 	}
 
 	cmd.Flags().StringVar(&shaFlag, "sha", "", "git ref to find the most recent job for")
-	cmd.Flags().BoolVar(&forceJobID, "job", false, "force argument to be treated as job ID")
+	cmd.Flags().BoolVar(&forceJobID, "job", false, "force arguments to be treated as job IDs")
 	cmd.Flags().BoolVarP(&quiet, "quiet", "q", false, "suppress output (for use in hooks)")
 
 	return cmd
 }
+
+// resolvedArg holds locally-validated arg data before daemon contact.
+type resolvedArg struct {
+	jobID int64  // set if arg is a numeric job ID
+	sha   string // set if arg is a git ref (resolved SHA)
+	ref   string // original ref string (for error messages)
+}
+
+// waitMultiple resolves multiple args to job IDs and waits for all
+// concurrently. Returns exit code 1 if any job fails or has a FAIL
+// verdict.
+func waitMultiple(
+	cmd *cobra.Command,
+	args []string,
+	forceJobID, quiet bool,
+) error {
+	// Phase 1: Local validation (no daemon contact).
+	repoRoot, _ := git.GetRepoRoot(".")
+	resolved := make([]resolvedArg, 0, len(args))
+	for _, arg := range args {
+		if forceJobID {
+			id, err := strconv.ParseInt(arg, 10, 64)
+			if err != nil || id <= 0 {
+				return fmt.Errorf("invalid job ID: %s", arg)
+			}
+			resolved = append(resolved, resolvedArg{jobID: id})
+		} else {
+			// Try git ref first
+			var sha string
+			if repoRoot != "" {
+				if s, err := git.ResolveSHA(repoRoot, arg); err == nil {
+					sha = s
+				}
+			}
+			if sha != "" {
+				resolved = append(resolved, resolvedArg{sha: sha, ref: arg})
+			} else {
+				id, err := strconv.ParseInt(arg, 10, 64)
+				if err != nil || id <= 0 {
+					return fmt.Errorf(
+						"argument %q is not a valid git ref or job ID",
+						arg,
+					)
+				}
+				resolved = append(resolved, resolvedArg{jobID: id})
+			}
+		}
+	}
+
+	// Phase 2: Ensure daemon is running.
+	if err := ensureDaemon(); err != nil {
+		return fmt.Errorf("daemon not running: %w", err)
+	}
+
+	// Phase 3: Resolve git refs to job IDs via daemon.
+	jobIDs := make([]int64, 0, len(resolved))
+	for _, r := range resolved {
+		if r.jobID != 0 {
+			jobIDs = append(jobIDs, r.jobID)
+			continue
+		}
+		mainRoot, _ := git.GetMainRepoRoot(".")
+		if mainRoot == "" {
+			mainRoot = repoRoot
+		}
+		job, err := findJobForCommit(mainRoot, r.sha)
+		if err != nil {
+			return err
+		}
+		if job == nil {
+			if !quiet {
+				cmd.Printf("No job found for %s\n", r.ref)
+			}
+			cmd.SilenceErrors = true
+			cmd.SilenceUsage = true
+			return &exitError{code: 1}
+		}
+		jobIDs = append(jobIDs, job.ID)
+	}
+
+	addr := getDaemonAddr()
+
+	// Wait for all jobs concurrently.
+	// Always poll in quiet mode to avoid interleaved output from
+	// goroutines; we display results serially after all complete.
+	type result struct {
+		jobID int64
+		err   error
+	}
+	results := make([]result, len(jobIDs))
+	var wg sync.WaitGroup
+	for i, id := range jobIDs {
+		wg.Add(1)
+		go func(idx int, jobID int64) {
+			defer wg.Done()
+			err := waitForJob(cmd, addr, jobID, true)
+			results[idx] = result{jobID: jobID, err: err}
+		}(i, id)
+	}
+	wg.Wait()
+
+	// Report results serially.
+	var hasErr bool
+	for _, r := range results {
+		if r.err == nil {
+			continue
+		}
+		hasErr = true
+		if !quiet {
+			switch {
+			case errors.Is(r.err, ErrJobNotFound):
+				cmd.Printf("Job %d: no job found\n", r.jobID)
+			case isExitCode(r.err, 1):
+				cmd.Printf("Job %d: review has issues\n", r.jobID)
+			default:
+				cmd.Printf("Job %d: %v\n", r.jobID, r.err)
+			}
+		}
+	}
+
+	if hasErr {
+		cmd.SilenceErrors = true
+		cmd.SilenceUsage = true
+		return &exitError{code: 1}
+	}
+
+	return nil
+}
+
+// isExitCode reports whether err is an *exitError with the given code.
+func isExitCode(err error, code int) bool {
+	var e *exitError
+	if errors.As(err, &e) {
+		return e.code == code
+	}
+	return false
+}