ensure workflows are only created for specs with meaningful details

Author: mnkiefer

docs/src/content/docs/guides/campaigns.md

@@ -287,17 +287,18 @@ Campaign spec files participate in the normal `compile` workflow:
 - Validation checks both the spec itself (IDs, tracker labels, lifecycle state, etc.) and that all referenced `workflows` exist in `.github/workflows/`.
 - If any campaign spec has problems, `compile` fails with a `campaign validation failed` error until issues are fixed.
 
-For experimentation, you can also enable an **orchestrator workflow** per campaign:
+**Orchestrator workflows** are automatically generated for each campaign spec:
 
 ```bash wrap
-GH_AW_EXPERIMENTAL_CAMPAIGN_ORCHESTRATOR=1 gh aw compile
+gh aw compile
 ```
 
-When this environment variable is set and specs are valid:
+When specs are valid:
 
 - Each `<name>.campaign.md` generates an orchestrator markdown workflow named `<name>-campaign.md` next to the spec.
 - The orchestrator is compiled like any other workflow to `<name>-campaign.lock.yml`.
 - This makes campaigns first-class, compilable entry points while keeping specs declarative.
+- Orchestrators are only generated when the campaign spec has meaningful details (tracker labels, workflows, memory paths, or metrics glob).
 
 ### Interactive Campaign Designer
 

docs/src/content/docs/setup/cli.md

@@ -155,7 +155,7 @@ gh aw compile --strict --zizmor        # Strict mode with security scanning
 gh aw compile --validate --strict      # Validate schema and enforce strict mode
 ```
 
-**Campaign specs and orchestrators:** In repositories that define campaign spec files under `.github/workflows/*.campaign.md`, `gh aw compile` first validates those specs (including referenced `workflows`) and fails the compilation if any problems are found. When the environment variable `GH_AW_EXPERIMENTAL_CAMPAIGN_ORCHESTRATOR=1` is set, `compile` also synthesizes an orchestrator workflow for each valid spec (for example, `security-compliance.campaign.md` → `security-compliance-campaign.md`) and compiles it to a corresponding `.lock.yml` file.
+**Campaign specs and orchestrators:** In repositories that define campaign spec files under `.github/workflows/*.campaign.md`, `gh aw compile` first validates those specs (including referenced `workflows`) and fails the compilation if any problems are found. By default, `compile` also synthesizes an orchestrator workflow for each valid spec that has meaningful details (e.g., `security-compliance.campaign.md` → `security-compliance-campaign.md`) and compiles it to a corresponding `.lock.yml` file. Orchestrators are only generated when the campaign spec includes tracker labels, workflows, memory paths, or a metrics glob.
 
 See [Strict Mode reference](/gh-aw/reference/frontmatter/#strict-mode-strict) for frontmatter configuration and [Security Guide](/gh-aw/guides/security/#strict-mode-validation) for best practices.
 

pkg/campaign/orchestrator.go

@@ -34,22 +34,36 @@ func BuildOrchestrator(spec *CampaignSpec, campaignFilePath string) (*workflow.W
 	markdownBuilder := &strings.Builder{}
 	markdownBuilder.WriteString("# Campaign Orchestrator\n\n")
 	markdownBuilder.WriteString(fmt.Sprintf("This workflow orchestrates the '%s' campaign.\n\n", name))
+	
+	// Track whether we have any meaningful campaign details
+	hasDetails := false
+	
 	if spec.TrackerLabel != "" {
 		markdownBuilder.WriteString(fmt.Sprintf("- Tracker label: `%s`\n", spec.TrackerLabel))
+		hasDetails = true
 	}
 	if len(spec.Workflows) > 0 {
 		markdownBuilder.WriteString("- Associated workflows: ")
 		markdownBuilder.WriteString(strings.Join(spec.Workflows, ", "))
 		markdownBuilder.WriteString("\n")
+		hasDetails = true
 	}
 	if len(spec.MemoryPaths) > 0 {
 		markdownBuilder.WriteString("- Memory paths: ")
 		markdownBuilder.WriteString(strings.Join(spec.MemoryPaths, ", "))
 		markdownBuilder.WriteString("\n")
+		hasDetails = true
 	}
 	if spec.MetricsGlob != "" {
 		markdownBuilder.WriteString(fmt.Sprintf("- Metrics glob: `%s`\n", spec.MetricsGlob))
+		hasDetails = true
 	}
+	
+	// Return nil if the campaign spec has no meaningful details for the prompt
+	if !hasDetails {
+		return nil, ""
+	}
+	
 	markdownBuilder.WriteString("\nUse these details to coordinate workers, update metrics, and track progress for this campaign.\n")
 
 	data := &workflow.WorkflowData{

pkg/cli/compile_command.go

@@ -438,34 +438,37 @@ func CompileWorkflows(config CompileConfig) ([]*workflow.WorkflowData, error) {
 				}
 
 				// Campaign spec is valid and referenced workflows exist.
-				// Optionally synthesize an orchestrator workflow for this campaign
-				// and compile it via the standard workflow pipeline. This is gated
-				// behind an environment variable so campaign specs can be validated
-				// in CI without requiring experimental orchestrator support.
-				if !noEmit && os.Getenv("GH_AW_EXPERIMENTAL_CAMPAIGN_ORCHESTRATOR") == "1" {
+				// Synthesize an orchestrator workflow for this campaign
+				// and compile it via the standard workflow pipeline.
+				if !noEmit {
 					orchestratorData, orchestratorPath := campaign.BuildOrchestrator(spec, resolvedFile)
-					lockFile := strings.TrimSuffix(orchestratorPath, ".md") + ".lock.yml"
-					result.CompiledFile = lockFile
-
-					if err := CompileWorkflowDataWithValidation(compiler, orchestratorData, orchestratorPath, verbose && !jsonOutput, zizmor && !noEmit, poutine && !noEmit, actionlint && !noEmit, strict, validate && !noEmit); err != nil {
-						if !jsonOutput {
-							fmt.Fprintln(os.Stderr, err.Error())
+					
+					// Only compile orchestrator if BuildOrchestrator returned valid data
+					// (it returns nil if the campaign has no meaningful prompt content)
+					if orchestratorData != nil {
+						lockFile := strings.TrimSuffix(orchestratorPath, ".md") + ".lock.yml"
+						result.CompiledFile = lockFile
+
+						if err := CompileWorkflowDataWithValidation(compiler, orchestratorData, orchestratorPath, verbose && !jsonOutput, zizmor && !noEmit, poutine && !noEmit, actionlint && !noEmit, strict, validate && !noEmit); err != nil {
+							if !jsonOutput {
+								fmt.Fprintln(os.Stderr, err.Error())
+							}
+							errorMessages = append(errorMessages, err.Error())
+							errorCount++
+							stats.Errors++
+							stats.FailedWorkflows = append(stats.FailedWorkflows, filepath.Base(orchestratorPath))
+
+							result.Valid = false
+							result.Errors = append(result.Errors, ValidationError{
+								Type:    "compilation_error",
+								Message: err.Error(),
+							})
+							validationResults = append(validationResults, result)
+							continue
 						}
-						errorMessages = append(errorMessages, err.Error())
-						errorCount++
-						stats.Errors++
-						stats.FailedWorkflows = append(stats.FailedWorkflows, filepath.Base(orchestratorPath))
 
-						result.Valid = false
-						result.Errors = append(result.Errors, ValidationError{
-							Type:    "compilation_error",
-							Message: err.Error(),
-						})
-						validationResults = append(validationResults, result)
-						continue
+						compiledCount++
 					}
-
-					compiledCount++
 				}
 
 				if verbose && !jsonOutput {
@@ -747,33 +750,36 @@ func CompileWorkflows(config CompileConfig) ([]*workflow.WorkflowData, error) {
 			}
 
 			// Campaign spec is valid and referenced workflows exist.
-			// Optionally synthesize an orchestrator workflow for this campaign
-			// and compile it via the standard workflow pipeline. This is gated
-			// behind an environment variable so campaign specs can be validated
-			// in CI without requiring experimental orchestrator support.
-			if !noEmit && os.Getenv("GH_AW_EXPERIMENTAL_CAMPAIGN_ORCHESTRATOR") == "1" {
+			// Synthesize an orchestrator workflow for this campaign
+			// and compile it via the standard workflow pipeline.
+			if !noEmit {
 				orchestratorData, orchestratorPath := campaign.BuildOrchestrator(spec, file)
-				lockFile := strings.TrimSuffix(orchestratorPath, ".md") + ".lock.yml"
-				result.CompiledFile = lockFile
+				
+				// Only compile orchestrator if BuildOrchestrator returned valid data
+				// (it returns nil if the campaign has no meaningful prompt content)
+				if orchestratorData != nil {
+					lockFile := strings.TrimSuffix(orchestratorPath, ".md") + ".lock.yml"
+					result.CompiledFile = lockFile
 
-				if err := CompileWorkflowDataWithValidation(compiler, orchestratorData, orchestratorPath, verbose && !jsonOutput, zizmor && !noEmit, poutine && !noEmit, actionlint && !noEmit, strict, validate && !noEmit); err != nil {
-					if !jsonOutput {
-						fmt.Fprintln(os.Stderr, err.Error())
+					if err := CompileWorkflowDataWithValidation(compiler, orchestratorData, orchestratorPath, verbose && !jsonOutput, zizmor && !noEmit, poutine && !noEmit, actionlint && !noEmit, strict, validate && !noEmit); err != nil {
+						if !jsonOutput {
+							fmt.Fprintln(os.Stderr, err.Error())
+						}
+						errorCount++
+						stats.Errors++
+						stats.FailedWorkflows = append(stats.FailedWorkflows, filepath.Base(orchestratorPath))
+
+						result.Valid = false
+						result.Errors = append(result.Errors, ValidationError{
+							Type:    "compilation_error",
+							Message: err.Error(),
+						})
+						validationResults = append(validationResults, result)
+						continue
 					}
-					errorCount++
-					stats.Errors++
-					stats.FailedWorkflows = append(stats.FailedWorkflows, filepath.Base(orchestratorPath))
 
-					result.Valid = false
-					result.Errors = append(result.Errors, ValidationError{
-						Type:    "compilation_error",
-						Message: err.Error(),
-					})
-					validationResults = append(validationResults, result)
-					continue
+					successCount++
 				}
-
-				successCount++
 			}
 
 			if verbose && !jsonOutput {