Auto-add activation dependency to custom jobs without explicit needs (#3458)

Author: Copilot

.github/workflows/super-linter-report.lock.yml

@@ -109,7 +109,7 @@ func (c *Compiler) buildJobs(data *WorkflowData, markdownPath string) error {
 	}
 
 	// Build additional custom jobs from frontmatter jobs section
-	if err := c.buildCustomJobs(data); err != nil {
+	if err := c.buildCustomJobs(data, activationJobCreated); err != nil {
 		return fmt.Errorf("failed to build custom jobs: %w", err)
 	}
 
@@ -730,15 +730,17 @@ func (c *Compiler) extractJobsFromFrontmatter(frontmatter map[string]any) map[st
 }
 
 // buildCustomJobs creates custom jobs defined in the frontmatter jobs section
-func (c *Compiler) buildCustomJobs(data *WorkflowData) error {
+func (c *Compiler) buildCustomJobs(data *WorkflowData, activationJobCreated bool) error {
 	for jobName, jobConfig := range data.Jobs {
 		if configMap, ok := jobConfig.(map[string]any); ok {
 			job := &Job{
 				Name: jobName,
 			}
 
 			// Extract job dependencies
+			hasExplicitNeeds := false
 			if needs, hasNeeds := configMap["needs"]; hasNeeds {
+				hasExplicitNeeds = true
 				if needsList, ok := needs.([]any); ok {
 					for _, need := range needsList {
 						if needStr, ok := need.(string); ok {
@@ -751,6 +753,13 @@ func (c *Compiler) buildCustomJobs(data *WorkflowData) error {
 				}
 			}
 
+			// If no explicit needs and activation job exists, automatically add activation as dependency
+			// This ensures custom jobs wait for workflow validation before executing
+			if !hasExplicitNeeds && activationJobCreated {
+				job.Needs = append(job.Needs, constants.ActivationJobName)
+				log.Printf("Added automatic dependency: custom job '%s' now depends on '%s'", jobName, constants.ActivationJobName)
+			}
+
 			// Extract other job properties
 			if runsOn, hasRunsOn := configMap["runs-on"]; hasRunsOn {
 				if runsOnStr, ok := runsOn.(string); ok {

pkg/workflow/compiler_jobs.go

@@ -613,3 +613,140 @@ func TestJobManager_GenerateMermaidGraph(t *testing.T) {
 		})
 	}
 }
+
+func TestBuildCustomJobsActivationDependency(t *testing.T) {
+	tests := []struct {
+		name                 string
+		jobs                 map[string]any
+		activationJobCreated bool
+		expectedDependencies map[string][]string
+		description          string
+	}{
+		{
+			name: "custom job without explicit needs should depend on activation",
+			jobs: map[string]any{
+				"super_linter": map[string]any{
+					"runs-on": "ubuntu-latest",
+					"steps": []any{
+						map[string]any{
+							"name": "Run linter",
+							"run":  "echo 'linting'",
+						},
+					},
+				},
+			},
+			activationJobCreated: true,
+			expectedDependencies: map[string][]string{
+				"super_linter": {"activation"},
+			},
+			description: "Custom job without explicit needs should automatically depend on activation",
+		},
+		{
+			name: "custom job with explicit needs should not get activation dependency",
+			jobs: map[string]any{
+				"custom_job": map[string]any{
+					"runs-on": "ubuntu-latest",
+					"needs":   []any{"other_job"},
+					"steps": []any{
+						map[string]any{
+							"name": "Run custom",
+							"run":  "echo 'custom'",
+						},
+					},
+				},
+			},
+			activationJobCreated: true,
+			expectedDependencies: map[string][]string{
+				"custom_job": {"other_job"},
+			},
+			description: "Custom job with explicit needs should keep its own dependencies",
+		},
+		{
+			name: "custom job without activation should have no automatic dependency",
+			jobs: map[string]any{
+				"custom_job": map[string]any{
+					"runs-on": "ubuntu-latest",
+					"steps": []any{
+						map[string]any{
+							"name": "Run custom",
+							"run":  "echo 'custom'",
+						},
+					},
+				},
+			},
+			activationJobCreated: false,
+			expectedDependencies: map[string][]string{
+				"custom_job": nil,
+			},
+			description: "Custom job should not have activation dependency when activation job doesn't exist",
+		},
+		{
+			name: "multiple custom jobs without explicit needs",
+			jobs: map[string]any{
+				"linter": map[string]any{
+					"runs-on": "ubuntu-latest",
+					"steps": []any{
+						map[string]any{"name": "Lint", "run": "lint"},
+					},
+				},
+				"formatter": map[string]any{
+					"runs-on": "ubuntu-latest",
+					"steps": []any{
+						map[string]any{"name": "Format", "run": "fmt"},
+					},
+				},
+			},
+			activationJobCreated: true,
+			expectedDependencies: map[string][]string{
+				"linter":    {"activation"},
+				"formatter": {"activation"},
+			},
+			description: "Multiple custom jobs should all depend on activation",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			c := &Compiler{
+				jobManager: NewJobManager(),
+			}
+
+			data := &WorkflowData{
+				Jobs: tt.jobs,
+			}
+
+			err := c.buildCustomJobs(data, tt.activationJobCreated)
+			if err != nil {
+				t.Fatalf("%s: buildCustomJobs() error = %v", tt.description, err)
+			}
+
+			// Verify each job has expected dependencies
+			for jobName, expectedNeeds := range tt.expectedDependencies {
+				job, exists := c.jobManager.jobs[jobName]
+				if !exists {
+					t.Fatalf("%s: job '%s' not found in job manager", tt.description, jobName)
+				}
+
+				if len(job.Needs) != len(expectedNeeds) {
+					t.Errorf("%s: job '%s' has %d dependencies, expected %d. Got: %v, Expected: %v",
+						tt.description, jobName, len(job.Needs), len(expectedNeeds), job.Needs, expectedNeeds)
+					continue
+				}
+
+				if expectedNeeds == nil {
+					if len(job.Needs) > 0 {
+						t.Errorf("%s: job '%s' should have no dependencies, got: %v", tt.description, jobName, job.Needs)
+					}
+					continue
+				}
+
+				for i, expected := range expectedNeeds {
+					if job.Needs[i] != expected {
+						t.Errorf("%s: job '%s' dependency[%d] = %s, expected %s",
+							tt.description, jobName, i, job.Needs[i], expected)
+					}
+				}
+			}
+		})
+	}
+}