Add weather-themed output, freeze handling, branch/tag flags, and tests

- Weather-themed outcome symbols and labels (↓ synced, ⚡ realigned,
  · current, ~ fog/skipped, ❄ frozen, ✗ failed)
- Graceful fetch-failure freeze: auth/network errors mark all branches
  as RainOutcomeFrozen (exits 0, NBD tone) instead of hard-failing
- fetchFailureReason() classifies auth vs network vs generic errors
- RainOptions: BranchMode, SyncTags, MainlinePatterns fields
- matchesPatterns() for user forecast patterns (exact + prefix match)
- BranchSyncMode: mainline/checked-out/all-local/all-branches
- createLocalTrackingFromRemotes() for all-branches mode
- --branch-mode and --tags CLI flags wired through to RainOptions
- Fix loader.go setDefaults() missing branch_mode/sync_tags/mainline_patterns
- Fix cmd/root_test.go assertions to match new weather-themed labels
- Unit tests: internal/config and internal/safety
- UAT script: scripts/uat.sh — 9 end-to-end scenarios with real git repos

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: bschellenberger2600

cmd/root.go

@@ -202,81 +202,141 @@ func runRain(_ *cobra.Command, _ []string) error {
 
 	totalUpdated := 0
 	totalSkipped := 0
+	totalFrozen := 0
 	totalFailed := 0
-	repoFailures := 0
 
 	for _, repo := range active {
-		fmt.Printf("Repo: %s\n", repo.Name)
+		fmt.Printf("  %s\n", repo.Name)
 
 		if rainFetchOnly {
 			if fetchErr := fetchOnly(repo.Path); fetchErr != nil {
-				repoFailures++
-				fmt.Printf("  ❌ fetch failed: %s\n\n", safety.SanitizeText(fetchErr.Error()))
+				fmt.Printf("    ❄  (all branches): %s\n\n",
+					safety.SanitizeText(fetchFailureMessage(fetchErr.Error())))
+				totalFrozen++
 				continue
 			}
-			fmt.Println("  ✓ fetched")
+			fmt.Println("    ↓  fetched")
 			fmt.Println()
 			totalUpdated++
 			continue
 		}
 
 		res, rainErr := git.RainRepository(repo.Path, rainOpts)
 		if rainErr != nil {
-			repoFailures++
-			fmt.Printf("  ❌ failed: %s\n\n", safety.SanitizeText(rainErr.Error()))
+			fmt.Printf("    ✗  failed: %s\n\n", safety.SanitizeText(rainErr.Error()))
+			totalFailed++
 			continue
 		}
 		if len(res.Branches) == 0 {
-			fmt.Println("  ⊘ no local branches found")
+			fmt.Println("    ·  no local branches")
 			fmt.Println()
 			continue
 		}
 
 		for _, br := range res.Branches {
-			symbol := "⊘"
-			switch br.Outcome {
-			case git.RainOutcomeUpdated:
-				symbol = "✓"
-			case git.RainOutcomeUpdatedRisky:
-				symbol = "⚠️"
-			case git.RainOutcomeFailed:
-				symbol = "❌"
-			}
-			line := fmt.Sprintf("  %s %s", symbol, br.Branch)
+			symbol := weatherSymbol(br.Outcome)
+			line := fmt.Sprintf("    %s  %s", symbol, br.Branch)
 			if br.Upstream != "" {
-				line += " <- " + br.Upstream
+				line += " ← " + br.Upstream
 			}
-			line += ": " + br.Outcome
+			line += ": " + outcomeLabel(br.Outcome)
 			if br.Message != "" {
-				line += " (" + safety.SanitizeText(strings.TrimSpace(br.Message)) + ")"
+				line += " — " + safety.SanitizeText(strings.TrimSpace(br.Message))
 			}
 			if br.BackupBranch != "" {
-				line += " backup=" + br.BackupBranch
+				line += " (backup: " + br.BackupBranch + ")"
 			}
 			fmt.Println(line)
 		}
 		fmt.Println()
 
 		totalUpdated += res.Updated
 		totalSkipped += res.Skipped
+		totalFrozen += res.Frozen
 		totalFailed += res.Failed
-		if res.Failed > 0 {
-			repoFailures++
-		}
 	}
 
-	fmt.Println(strings.Repeat("=", 50))
-	fmt.Println("🌧️  Rain complete")
-	fmt.Printf("Updated branches: %d\n", totalUpdated)
-	fmt.Printf("Skipped branches: %d\n", totalSkipped)
-	fmt.Printf("Failed branches: %d\n", totalFailed)
-
-	if repoFailures > 0 || totalFailed > 0 {
-		return fmt.Errorf("rain completed with failures")
+	fmt.Println(strings.Repeat("─", 48))
+	if totalFailed > 0 {
+		fmt.Printf("🌧  rain stopped — %d updated, %d skipped, %d frozen, %d failed\n",
+			totalUpdated, totalSkipped, totalFrozen, totalFailed)
+		return fmt.Errorf("%d branch(es) failed — check output above", totalFailed)
 	}
+	if totalFrozen > 0 {
+		fmt.Printf("🌧  rain delivered — %d updated, %d skipped, %d frozen (try again when reachable)\n",
+			totalUpdated, totalSkipped, totalFrozen)
+		return nil
+	}
+	fmt.Printf("🌧  rain delivered — %d updated, %d skipped\n", totalUpdated, totalSkipped)
 	return nil
 }
 
+// weatherSymbol returns the terminal symbol for a branch outcome.
+func weatherSymbol(outcome string) string {
+	switch outcome {
+	case git.RainOutcomeUpdated:
+		return "↓"
+	case git.RainOutcomeUpdatedRisky:
+		return "⚡"
+	case git.RainOutcomeUpToDate:
+		return "·"
+	case git.RainOutcomeFrozen:
+		return "❄"
+	case git.RainOutcomeFailed:
+		return "✗"
+	default:
+		return "~" // fog — skipped for any local-state reason
+	}
+}
+
+// outcomeLabel returns a calm, readable label for a branch outcome.
+func outcomeLabel(outcome string) string {
+	switch outcome {
+	case git.RainOutcomeUpdated:
+		return "synced"
+	case git.RainOutcomeUpdatedRisky:
+		return "realigned"
+	case git.RainOutcomeUpToDate:
+		return "current"
+	case git.RainOutcomeFrozen:
+		return "frozen"
+	case git.RainOutcomeFailed:
+		return "failed"
+	case git.RainOutcomeSkippedNoUpstream:
+		return "no upstream"
+	case git.RainOutcomeSkippedAmbiguousUpstream:
+		return "ambiguous upstream"
+	case git.RainOutcomeSkippedUpstreamMissing:
+		return "upstream missing"
+	case git.RainOutcomeSkippedCheckedOut:
+		return "checked out elsewhere"
+	case git.RainOutcomeSkippedLocalAhead:
+		return "local ahead"
+	case git.RainOutcomeSkippedDiverged:
+		return "diverged"
+	case git.RainOutcomeSkippedUnsafeMerge:
+		return "unsafe merge"
+	case git.RainOutcomeSkippedUnsafeDirty:
+		return "dirty worktree"
+	default:
+		return outcome
+	}
+}
+
+// fetchFailureMessage extracts a calm message from a fetchOnly error.
+func fetchFailureMessage(errMsg string) string {
+	s := strings.ToLower(errMsg)
+	if strings.Contains(s, "authentication") || strings.Contains(s, "permission denied") ||
+		strings.Contains(s, "could not read") || strings.Contains(s, "401") || strings.Contains(s, "403") {
+		return "could not authenticate with remote — check your credentials and try again"
+	}
+	if strings.Contains(s, "could not resolve") || strings.Contains(s, "connection") ||
+		strings.Contains(s, "timed out") || strings.Contains(s, "network") {
+		return "could not reach remote — check your network and try again"
+	}
+	return "fetch did not complete — try again when the remote is reachable"
+}
+
 func runDryRun(scanOpts git.ScanOptions, rainOpts git.RainOptions) error {
 	repos, err := git.ScanRepositories(scanOpts)
 	if err != nil {
@@ -411,78 +471,72 @@ func runRainOnRepos(repos []git.Repository, opts git.RainOptions) error {
 
 	totalUpdated := 0
 	totalSkipped := 0
+	totalFrozen := 0
 	totalFailed := 0
-	repoFailures := 0
 
 	for _, repo := range repos {
-		fmt.Printf("Repo: %s\n", repo.Name)
+		fmt.Printf("  %s\n", repo.Name)
 
 		if rainFetchOnly {
 			if fetchErr := fetchOnly(repo.Path); fetchErr != nil {
-				repoFailures++
-				fmt.Printf("  ❌ fetch failed: %s\n\n", safety.SanitizeText(fetchErr.Error()))
+				fmt.Printf("    ❄  (all branches): %s\n\n",
+					safety.SanitizeText(fetchFailureMessage(fetchErr.Error())))
+				totalFrozen++
 				continue
 			}
-			fmt.Println("  ✓ fetched")
+			fmt.Println("    ↓  fetched")
 			fmt.Println()
 			totalUpdated++
 			continue
 		}
 
 		res, rainErr := git.RainRepository(repo.Path, opts)
 		if rainErr != nil {
-			repoFailures++
-			fmt.Printf("  ❌ failed: %s\n\n", safety.SanitizeText(rainErr.Error()))
+			fmt.Printf("    ✗  failed: %s\n\n", safety.SanitizeText(rainErr.Error()))
+			totalFailed++
 			continue
 		}
 		if len(res.Branches) == 0 {
-			fmt.Println("  ⊘ no local branches found")
+			fmt.Println("    ·  no local branches")
 			fmt.Println()
 			continue
 		}
 
 		for _, br := range res.Branches {
-			symbol := "⊘"
-			switch br.Outcome {
-			case git.RainOutcomeUpdated:
-				symbol = "✓"
-			case git.RainOutcomeUpdatedRisky:
-				symbol = "⚠️"
-			case git.RainOutcomeFailed:
-				symbol = "❌"
-			}
-			line := fmt.Sprintf("  %s %s", symbol, br.Branch)
+			symbol := weatherSymbol(br.Outcome)
+			line := fmt.Sprintf("    %s  %s", symbol, br.Branch)
 			if br.Upstream != "" {
-				line += " <- " + br.Upstream
+				line += " ← " + br.Upstream
 			}
-			line += ": " + br.Outcome
+			line += ": " + outcomeLabel(br.Outcome)
 			if br.Message != "" {
-				line += " (" + safety.SanitizeText(strings.TrimSpace(br.Message)) + ")"
+				line += " — " + safety.SanitizeText(strings.TrimSpace(br.Message))
 			}
 			if br.BackupBranch != "" {
-				line += " backup=" + br.BackupBranch
+				line += " (backup: " + br.BackupBranch + ")"
 			}
 			fmt.Println(line)
 		}
 		fmt.Println()
 
 		totalUpdated += res.Updated
 		totalSkipped += res.Skipped
+		totalFrozen += res.Frozen
 		totalFailed += res.Failed
-		if res.Failed > 0 {
-			repoFailures++
-		}
 	}
 
-	fmt.Println(strings.Repeat("=", 50))
-	fmt.Println("🌧️  Rain complete")
-	fmt.Printf("Updated branches: %d\n", totalUpdated)
-	fmt.Printf("Skipped branches: %d\n", totalSkipped)
-	fmt.Printf("Failed branches: %d\n", totalFailed)
-
-	if repoFailures > 0 || totalFailed > 0 {
-		return fmt.Errorf("rain completed with failures")
+	fmt.Println(strings.Repeat("─", 48))
+	if totalFailed > 0 {
+		fmt.Printf("🌧  rain stopped — %d updated, %d skipped, %d frozen, %d failed\n",
+			totalUpdated, totalSkipped, totalFrozen, totalFailed)
+		return fmt.Errorf("%d branch(es) failed — check output above", totalFailed)
+	}
+	if totalFrozen > 0 {
+		fmt.Printf("🌧  rain delivered — %d updated, %d skipped, %d frozen (try again when reachable)\n",
+			totalUpdated, totalSkipped, totalFrozen)
+		return nil
 	}
+	fmt.Printf("🌧  rain delivered — %d updated, %d skipped\n", totalUpdated, totalSkipped)
 	return nil
 }
 

cmd/root_test.go

@@ -87,8 +87,8 @@ func TestRunRain_SafeModeSkipsLocalAheadBranch(t *testing.T) {
 	if runErr != nil {
 		t.Fatalf("runRain() safe mode error = %v", runErr)
 	}
-	if !strings.Contains(output, "skipped-local-ahead") {
-		t.Fatalf("expected safe mode output to mention skipped-local-ahead, got:\n%s", output)
+	if !strings.Contains(output, "local ahead") {
+		t.Fatalf("expected safe mode output to mention 'local ahead', got:\n%s", output)
 	}
 	if got := testutil.GetCurrentSHA(t, repo.Path()); got != localAheadSHA {
 		t.Fatalf("safe mode should preserve local-ahead SHA (want=%s got=%s)", localAheadSHA, got)
@@ -125,8 +125,8 @@ func TestRunRain_RiskyFlagResetsLocalAheadBranch(t *testing.T) {
 	if runErr != nil {
 		t.Fatalf("runRain() risky mode error = %v", runErr)
 	}
-	if !strings.Contains(output, "updated-risky") {
-		t.Fatalf("expected risky output to mention updated-risky, got:\n%s", output)
+	if !strings.Contains(output, "realigned") {
+		t.Fatalf("expected risky output to mention 'realigned', got:\n%s", output)
 	}
 	if got := testutil.GetCurrentSHA(t, repo.Path()); got != remoteSHA {
 		t.Fatalf("risky mode should reset branch to remote SHA (want=%s got=%s)", remoteSHA, got)