fix DM config loading

Author: Thomas Stromberg

pkg/config/config.go

@@ -374,6 +374,7 @@ func (m *Manager) LoadConfig(ctx context.Context, org string) error {
 			"team_id":             config.Global.TeamID,
 			"email_domain":        config.Global.EmailDomain,
 			"daily_reminders":     config.Global.DailyReminders,
+			"reminder_dm_delay":   config.Global.ReminderDMDelay,
 			"total_channels":      len(config.Channels),
 			"muted_channels":      muted,
 			"wildcard_channels":   wildcard,
@@ -575,20 +576,36 @@ func (m *Manager) ReminderDMDelay(org, channel string) int {
 
 	config, exists := m.configs[org]
 	if !exists {
+		slog.Debug("no config for org - using default delay",
+			logFieldOrg, org,
+			"default_delay_mins", defaultReminderDMDelayMinutes)
 		return defaultReminderDMDelayMinutes
 	}
 
 	// Check for channel-specific override
 	if channelConfig, ok := config.Channels[channel]; ok {
 		if channelConfig.ReminderDMDelay != nil {
+			slog.Debug("using channel-specific reminder delay",
+				logFieldOrg, org,
+				"channel", channel,
+				"delay_mins", *channelConfig.ReminderDMDelay)
 			return *channelConfig.ReminderDMDelay
 		}
 	}
 
 	// Return global setting (or default if not set)
 	if config.Global.ReminderDMDelay > 0 {
+		slog.Debug("using global reminder delay",
+			logFieldOrg, org,
+			"channel", channel,
+			"delay_mins", config.Global.ReminderDMDelay)
 		return config.Global.ReminderDMDelay
 	}
+	slog.Debug("global delay is 0 or unset - using default",
+		logFieldOrg, org,
+		"channel", channel,
+		"global_value", config.Global.ReminderDMDelay,
+		"default_delay_mins", defaultReminderDMDelayMinutes)
 	return defaultReminderDMDelayMinutes
 }
 

pkg/config/config_test.go

@@ -1071,6 +1071,112 @@ channels: [1, 2, 3]
 	}
 }
 
+func TestManager_LoadConfigCodeGROOVEProdConfig(t *testing.T) {
+	// Test with actual production config from codeGROOVE-dev/.codeGROOVE/slack.yaml
+	prodYAML := `global:
+    team_id: T09CJ7X7T7Y
+    email_domain: codegroove.dev
+    reminder_dm_delay: 1
+
+channels:
+    goose:
+      mute: true
+
+    all-codegroove:
+      repos:
+        - "*"
+
+    social:
+      repos:
+        - goose
+        - sprinkler
+        - slacker
+`
+
+	handler := func(w http.ResponseWriter, r *http.Request) {
+		content := base64.StdEncoding.EncodeToString([]byte(prodYAML))
+		encoding := "base64"
+		response := github.RepositoryContent{
+			Type:     github.String("file"),
+			Content:  &content,
+			Encoding: &encoding,
+		}
+		w.Header().Set("Content-Type", "application/json")
+		if err := json.NewEncoder(w).Encode(response); err != nil {
+			t.Errorf("failed to encode response: %v", err)
+		}
+	}
+
+	client, server := createTestGitHubClient(handler)
+	defer server.Close()
+
+	m := New()
+	m.SetGitHubClient("codeGROOVE-dev", client)
+
+	ctx := context.Background()
+	err := m.LoadConfig(ctx, "codeGROOVE-dev")
+	if err != nil {
+		t.Fatalf("unexpected error loading production config: %v", err)
+	}
+
+	// Verify config was loaded correctly
+	cfg, exists := m.Config("codeGROOVE-dev")
+	if !exists {
+		t.Fatal("expected config to exist after loading")
+	}
+	if cfg.Global.TeamID != "T09CJ7X7T7Y" {
+		t.Errorf("expected TeamID T09CJ7X7T7Y, got %q", cfg.Global.TeamID)
+	}
+	if cfg.Global.EmailDomain != "codegroove.dev" {
+		t.Errorf("expected email domain codegroove.dev, got %q", cfg.Global.EmailDomain)
+	}
+	if cfg.Global.ReminderDMDelay != 1 {
+		t.Errorf("expected reminder delay 1 minute, got %d", cfg.Global.ReminderDMDelay)
+	}
+	if len(cfg.Channels) != 3 {
+		t.Errorf("expected 3 channels, got %d", len(cfg.Channels))
+	}
+
+	// Verify goose channel is muted
+	gooseChannel, exists := cfg.Channels["goose"]
+	if !exists {
+		t.Error("expected goose channel to exist")
+	}
+	if !gooseChannel.Mute {
+		t.Error("expected goose channel to be muted")
+	}
+
+	// Verify all-codegroove has wildcard
+	allChannel, exists := cfg.Channels["all-codegroove"]
+	if !exists {
+		t.Error("expected all-codegroove channel to exist")
+	}
+	if len(allChannel.Repos) != 1 || allChannel.Repos[0] != "*" {
+		t.Errorf("expected all-codegroove to have wildcard repo, got %v", allChannel.Repos)
+	}
+
+	// Verify social channel repos
+	socialChannel, exists := cfg.Channels["social"]
+	if !exists {
+		t.Error("expected social channel to exist")
+	}
+	expectedRepos := []string{"goose", "sprinkler", "slacker"}
+	if len(socialChannel.Repos) != len(expectedRepos) {
+		t.Errorf("expected %d repos in social channel, got %d", len(expectedRepos), len(socialChannel.Repos))
+	}
+	for i, repo := range expectedRepos {
+		if i >= len(socialChannel.Repos) || socialChannel.Repos[i] != repo {
+			t.Errorf("expected repo %q at index %d in social channel, got %v", repo, i, socialChannel.Repos)
+		}
+	}
+
+	// Verify ReminderDMDelay returns correct value
+	delay := m.ReminderDMDelay("codeGROOVE-dev", "social")
+	if delay != 1 {
+		t.Errorf("expected ReminderDMDelay to return 1 minute, got %d", delay)
+	}
+}
+
 func TestManager_LoadConfigEmptyContent(t *testing.T) {
 	handler := func(w http.ResponseWriter, r *http.Request) {
 		// Return a response with nil Content

pkg/notify/notify.go

@@ -145,7 +145,15 @@ func emojiFromWorkflowState(workflowState string, nextActions map[string]turn.Ac
 		return ":test_tube:", "?st=tests_running"
 
 	case string(turn.StateTestedWaitingForAssignment):
-		// Waiting for reviewers to be assigned
+		// Check if tests are actually broken despite "TESTED" state
+		// This can happen if new commits pushed after tests passed
+		if len(nextActions) > 0 {
+			action := PrimaryAction(nextActions)
+			if action == string(turn.ActionFixTests) {
+				return ":cockroach:", "?st=tests_broken"
+			}
+		}
+		// Tests passed, waiting for reviewers to be assigned
 		return ":shrug:", "?st=awaiting_assignment"
 
 	case string(turn.StateAssignedWaitingForReview):

pkg/notify/prefix_test.go

@@ -60,6 +60,14 @@ func TestPrefixForAnalysis(t *testing.T) {
 			},
 			expectedEmoji: ":shrug:",
 		},
+		{
+			name:          "TESTED_WAITING_FOR_ASSIGNMENT with broken tests shows :cockroach:",
+			workflowState: string(turn.StateTestedWaitingForAssignment),
+			nextAction: map[string]turn.Action{
+				"author": {Kind: turn.ActionFixTests},
+			},
+			expectedEmoji: ":cockroach:",
+		},
 		{
 			name:          "ASSIGNED_WAITING_FOR_REVIEW shows :hourglass:",
 			workflowState: string(turn.StateAssignedWaitingForReview),