diff --git a/pkg/workflow/compiler_parse.go b/pkg/workflow/compiler_parse.go
index b948b8bb2db..36c31b98ac9 100644
--- a/pkg/workflow/compiler_parse.go
+++ b/pkg/workflow/compiler_parse.go
@@ -46,7 +46,7 @@ func (c *Compiler) ParseWorkflowFile(markdownPath string) (*WorkflowData, error)
 	}
 
 	// Preprocess schedule fields to convert human-friendly format to cron expressions
-	if err := c.preprocessScheduleFields(result.Frontmatter); err != nil {
+	if err := c.preprocessScheduleFields(result.Frontmatter, markdownPath, string(content)); err != nil {
 		return nil, err
 	}
 
diff --git a/pkg/workflow/frontmatter_extraction.go b/pkg/workflow/frontmatter_extraction.go
index 59754c49b98..e1909c13f2c 100644
--- a/pkg/workflow/frontmatter_extraction.go
+++ b/pkg/workflow/frontmatter_extraction.go
@@ -130,7 +130,7 @@ func (c *Compiler) extractTopLevelYAMLSection(frontmatter map[string]any, key st
 // Exception: names fields in sections with __gh_aw_native_label_filter__ marker in frontmatter are NOT commented out
 func (c *Compiler) commentOutProcessedFieldsInOnSection(yamlStr string, frontmatter map[string]any) string {
 	frontmatterLog.Print("Processing 'on' section to comment out processed fields")
-	
+
 	// Check frontmatter for native label filter markers
 	nativeLabelFilterSections := make(map[string]bool)
 	if onValue, exists := frontmatter["on"]; exists {
@@ -289,42 +289,42 @@ func (c *Compiler) commentOutProcessedFieldsInOnSection(yamlStr string, frontmat
 			// Look back to see if the previous uncommented line was "names:"
 			// Only do this if NOT using native label filtering for this section
 			if !nativeLabelFilterSections[currentSection] {
-			if len(result) > 0 {
-				for i := len(result) - 1; i >= 0; i-- {
-					prevLine := result[i]
-					prevTrimmed := strings.TrimSpace(prevLine)
-
-					// Skip empty lines
-					if prevTrimmed == "" {
-						continue
-					}
+				if len(result) > 0 {
+					for i := len(result) - 1; i >= 0; i-- {
+						prevLine := result[i]
+						prevTrimmed := strings.TrimSpace(prevLine)
+
+						// Skip empty lines
+						if prevTrimmed == "" {
+							continue
+						}
 
-					// If we find "names:", and current line is an array item, comment it
-					if strings.Contains(prevTrimmed, "names:") && strings.Contains(prevTrimmed, "# Label filtering") {
-						if strings.HasPrefix(trimmedLine, "-") {
-							shouldComment = true
-							commentReason = " # Label filtering applied via job conditions"
+						// If we find "names:", and current line is an array item, comment it
+						if strings.Contains(prevTrimmed, "names:") && strings.Contains(prevTrimmed, "# Label filtering") {
+							if strings.HasPrefix(trimmedLine, "-") {
+								shouldComment = true
+								commentReason = " # Label filtering applied via job conditions"
+							}
+							break
 						}
-						break
-					}
 
-					// If we find a different field or commented names array item, break
-					if !strings.HasPrefix(prevTrimmed, "#") || !strings.Contains(prevTrimmed, "Label filtering") {
-						break
-					}
+						// If we find a different field or commented names array item, break
+						if !strings.HasPrefix(prevTrimmed, "#") || !strings.Contains(prevTrimmed, "Label filtering") {
+							break
+						}
 
-					// If it's a commented names array item, continue
-					if strings.HasPrefix(prevTrimmed, "# -") && strings.Contains(prevTrimmed, "Label filtering") {
-						if strings.HasPrefix(trimmedLine, "-") {
-							shouldComment = true
-							commentReason = " # Label filtering applied via job conditions"
+						// If it's a commented names array item, continue
+						if strings.HasPrefix(prevTrimmed, "# -") && strings.Contains(prevTrimmed, "Label filtering") {
+							if strings.HasPrefix(trimmedLine, "-") {
+								shouldComment = true
+								commentReason = " # Label filtering applied via job conditions"
+							}
+							continue
 						}
-						continue
-					}
 
-					break
+						break
+					}
 				}
-			}
 			} // Close native filter check
 		}
 
diff --git a/pkg/workflow/label_trigger_integration_test.go b/pkg/workflow/label_trigger_integration_test.go
index a9e984a65e0..50e2e2eccbf 100644
--- a/pkg/workflow/label_trigger_integration_test.go
+++ b/pkg/workflow/label_trigger_integration_test.go
@@ -11,7 +11,7 @@ func TestLabelTriggerIntegrationSimple(t *testing.T) {
 	}
 
 	compiler := NewCompiler(false, "", "test")
-	err := compiler.preprocessScheduleFields(frontmatter)
+	err := compiler.preprocessScheduleFields(frontmatter, "", "")
 	if err != nil {
 		t.Fatalf("preprocessScheduleFields() error = %v", err)
 	}
@@ -90,7 +90,7 @@ func TestLabelTriggerIntegrationIssue(t *testing.T) {
 	}
 
 	compiler := NewCompiler(false, "", "test")
-	err := compiler.preprocessScheduleFields(frontmatter)
+	err := compiler.preprocessScheduleFields(frontmatter, "", "")
 	if err != nil {
 		t.Fatalf("preprocessScheduleFields() error = %v", err)
 	}
@@ -120,7 +120,7 @@ func TestLabelTriggerIntegrationPullRequest(t *testing.T) {
 	}
 
 	compiler := NewCompiler(false, "", "test")
-	err := compiler.preprocessScheduleFields(frontmatter)
+	err := compiler.preprocessScheduleFields(frontmatter, "", "")
 	if err != nil {
 		t.Fatalf("preprocessScheduleFields() error = %v", err)
 	}
@@ -186,7 +186,7 @@ func TestLabelTriggerIntegrationDiscussion(t *testing.T) {
 	}
 
 	compiler := NewCompiler(false, "", "test")
-	err := compiler.preprocessScheduleFields(frontmatter)
+	err := compiler.preprocessScheduleFields(frontmatter, "", "")
 	if err != nil {
 		t.Fatalf("preprocessScheduleFields() error = %v", err)
 	}
@@ -249,7 +249,7 @@ func TestLabelTriggerIntegrationError(t *testing.T) {
 	}
 
 	compiler := NewCompiler(false, "", "test")
-	err := compiler.preprocessScheduleFields(frontmatter)
+	err := compiler.preprocessScheduleFields(frontmatter, "", "")
 	if err != nil {
 		t.Fatalf("preprocessScheduleFields() unexpected error = %v", err)
 	}
diff --git a/pkg/workflow/label_trigger_parser.go b/pkg/workflow/label_trigger_parser.go
index 297d6905e4d..8e30df96f5c 100644
--- a/pkg/workflow/label_trigger_parser.go
+++ b/pkg/workflow/label_trigger_parser.go
@@ -94,7 +94,7 @@ func expandLabelTriggerShorthand(entityType string, labelNames []string) map[str
 	triggerConfig := map[string]any{
 		"types": []any{"labeled"},
 	}
-	
+
 	// Only add names field for issues and pull_request (GitHub Actions supports it)
 	// For discussions, names field is not supported by GitHub Actions
 	if entityType == "issues" || entityType == "pull_request" {
diff --git a/pkg/workflow/label_trigger_parser_fuzz_test.go b/pkg/workflow/label_trigger_parser_fuzz_test.go
index 3b39306463e..f9760a05ccf 100644
--- a/pkg/workflow/label_trigger_parser_fuzz_test.go
+++ b/pkg/workflow/label_trigger_parser_fuzz_test.go
@@ -26,23 +26,23 @@ func FuzzParseLabelTriggerShorthand(f *testing.F) {
 	f.Add("issue  labeled  bug  enhancement")
 	f.Add("ISSUE LABELED BUG")
 	f.Add("Issue Labeled Bug")
-	
+
 	f.Fuzz(func(t *testing.T, input string) {
 		// The function should never panic regardless of input
 		entityType, labelNames, isLabelTrigger, err := parseLabelTriggerShorthand(input)
-		
+
 		// Validate the output is consistent
 		if isLabelTrigger {
 			// If it's recognized as a label trigger, must have entity type
 			if entityType == "" {
 				t.Errorf("isLabelTrigger=true but entityType is empty for input: %q", input)
 			}
-			
+
 			// If no error, must have at least one label name
 			if err == nil && len(labelNames) == 0 {
 				t.Errorf("isLabelTrigger=true and err=nil but no label names for input: %q", input)
 			}
-			
+
 			// If error is present, label names should be nil or empty
 			if err != nil && len(labelNames) > 0 {
 				t.Errorf("isLabelTrigger=true with error but labelNames is not empty for input: %q", input)
@@ -52,23 +52,23 @@ func FuzzParseLabelTriggerShorthand(f *testing.F) {
 			if entityType != "" {
 				t.Errorf("isLabelTrigger=false but entityType=%q for input: %q", entityType, input)
 			}
-			
+
 			// If not a label trigger, label names should be nil
 			if labelNames != nil {
 				t.Errorf("isLabelTrigger=false but labelNames=%v for input: %q", labelNames, input)
 			}
-			
+
 			// If not a label trigger, should not have an error
 			if err != nil {
 				t.Errorf("isLabelTrigger=false but has error for input: %q, error: %v", input, err)
 			}
 		}
-		
+
 		// Validate entity types are only the expected ones
 		if entityType != "" && entityType != "issues" && entityType != "pull_request" && entityType != "discussion" {
 			t.Errorf("unexpected entityType=%q for input: %q", entityType, input)
 		}
-		
+
 		// Validate label names don't contain empty strings
 		for _, label := range labelNames {
 			if label == "" {
@@ -88,7 +88,7 @@ func FuzzExpandLabelTriggerShorthand(f *testing.F) {
 	f.Add("issues", "bug,enhancement,priority-high")
 	f.Add("unknown", "test")
 	f.Add("", "bug")
-	
+
 	f.Fuzz(func(t *testing.T, entityType string, labelsStr string) {
 		// Parse labels string into array
 		var labelNames []string
@@ -99,32 +99,32 @@ func FuzzExpandLabelTriggerShorthand(f *testing.F) {
 				}
 			}
 		}
-		
+
 		if len(labelNames) == 0 {
 			// Skip if no labels
 			return
 		}
-		
+
 		// The function should never panic
 		result := expandLabelTriggerShorthand(entityType, labelNames)
-		
+
 		// Validate result structure
 		if result == nil {
 			t.Errorf("expandLabelTriggerShorthand returned nil for entityType=%q, labels=%v", entityType, labelNames)
 			return
 		}
-		
+
 		// Check for workflow_dispatch
 		if _, hasDispatch := result["workflow_dispatch"]; !hasDispatch {
 			t.Errorf("result missing workflow_dispatch for entityType=%q", entityType)
 		}
-		
+
 		// Check for trigger key (issues, pull_request, or discussion)
 		hasTrigger := false
 		for key := range result {
 			if key == "issues" || key == "pull_request" || key == "discussion" {
 				hasTrigger = true
-				
+
 				// Validate trigger structure
 				if triggerMap, ok := result[key].(map[string]any); ok {
 					// Check for types field
@@ -135,7 +135,7 @@ func FuzzExpandLabelTriggerShorthand(f *testing.F) {
 					} else if len(typeArray) == 0 {
 						t.Errorf("types array is empty for entityType=%q", entityType)
 					}
-					
+
 					// Check for names field
 					if names, hasNames := triggerMap["names"]; !hasNames {
 						t.Errorf("trigger missing names field for entityType=%q", entityType)
@@ -147,7 +147,7 @@ func FuzzExpandLabelTriggerShorthand(f *testing.F) {
 				}
 			}
 		}
-		
+
 		if !hasTrigger {
 			t.Errorf("result missing trigger key (issues/pull_request/discussion) for entityType=%q", entityType)
 		}
diff --git a/pkg/workflow/schedule_preprocessing.go b/pkg/workflow/schedule_preprocessing.go
index 34c592f0f6a..f39cd91746b 100644
--- a/pkg/workflow/schedule_preprocessing.go
+++ b/pkg/workflow/schedule_preprocessing.go
@@ -1,9 +1,11 @@
 package workflow
 
 import (
+	"errors"
 	"fmt"
 	"strings"
 
+	"github.com/githubnext/gh-aw/pkg/console"
 	"github.com/githubnext/gh-aw/pkg/logger"
 	"github.com/githubnext/gh-aw/pkg/parser"
 )
@@ -16,7 +18,7 @@ var scheduleFriendlyFormats = make(map[string]map[int]string)
 
 // preprocessScheduleFields converts human-friendly schedule expressions to cron expressions
 // in the frontmatter's "on" section. It modifies the frontmatter map in place.
-func (c *Compiler) preprocessScheduleFields(frontmatter map[string]any) error {
+func (c *Compiler) preprocessScheduleFields(frontmatter map[string]any, markdownPath string, content string) error {
 	schedulePreprocessingLog.Print("Preprocessing schedule fields in frontmatter")
 
 	// Check if "on" field exists
@@ -25,7 +27,7 @@ func (c *Compiler) preprocessScheduleFields(frontmatter map[string]any) error {
 		return nil
 	}
 
-	// Check if "on" is a string - might be a schedule expression, slash command shorthand, or label trigger shorthand
+	// Check if "on" is a string - might be a schedule expression, slash command shorthand, label trigger shorthand, or other trigger shorthand
 	if onStr, ok := onValue.(string); ok {
 		schedulePreprocessingLog.Printf("Processing on field as string: %s", onStr)
 
@@ -59,11 +61,28 @@ func (c *Compiler) preprocessScheduleFields(frontmatter map[string]any) error {
 			return nil
 		}
 
-		// Try to parse as a schedule expression
+		// Try the new unified trigger parser for other trigger shorthands
+		triggerIR, err := ParseTriggerShorthand(onStr)
+		if err != nil {
+			// Wrap the error with source location information
+			return c.createTriggerParseError(markdownPath, content, onStr, err)
+		}
+		if triggerIR != nil {
+			schedulePreprocessingLog.Printf("Converting shorthand 'on: %s' to structured trigger", onStr)
+
+			// Convert IR to YAML map
+			onMap := triggerIR.ToYAMLMap()
+			frontmatter["on"] = onMap
+
+			return nil
+		}
+
+		// Try to parse as a schedule expression (only if not already recognized as another trigger type)
 		parsedCron, original, err := parser.ParseSchedule(onStr)
 		if err != nil {
-			// Not a schedule expression, treat as a simple event trigger
-			schedulePreprocessingLog.Printf("Not a schedule expression: %s", onStr)
+			// Not a schedule expression either - leave as simple string trigger
+			// (simple event names like "push", "fork", etc. are valid)
+			schedulePreprocessingLog.Printf("Not a recognized shorthand or schedule: %s - leaving as-is", onStr)
 			return nil
 		}
 
@@ -323,6 +342,77 @@ func (c *Compiler) preprocessScheduleFields(frontmatter map[string]any) error {
 	return nil
 }
 
+// createTriggerParseError creates a detailed error for trigger parsing issues with source location
+func (c *Compiler) createTriggerParseError(filePath, content, triggerStr string, err error) error {
+	schedulePreprocessingLog.Printf("Creating trigger parse error for: %s", triggerStr)
+	
+	lines := strings.Split(content, "\n")
+	
+	// Find the line where "on:" appears in the frontmatter
+	var onLine int
+	var onColumn int
+	inFrontmatter := false
+	
+	for i, line := range lines {
+		lineNum := i + 1
+		
+		// Check for frontmatter delimiter
+		if strings.TrimSpace(line) == "---" {
+			if !inFrontmatter {
+				inFrontmatter = true
+			} else {
+				// End of frontmatter
+				break
+			}
+			continue
+		}
+		
+		if inFrontmatter {
+			// Look for "on:" field
+			trimmed := strings.TrimSpace(line)
+			if strings.HasPrefix(trimmed, "on:") {
+				onLine = lineNum
+				// Find the column where "on:" starts
+				onColumn = strings.Index(line, "on:") + 1
+				break
+			}
+		}
+	}
+	
+	// If we found the line, create a formatted error
+	if onLine > 0 {
+		// Create context lines around the error
+		var context []string
+		startLine := max(1, onLine-2)
+		endLine := min(len(lines), onLine+2)
+		
+		for i := startLine; i <= endLine; i++ {
+			if i-1 < len(lines) {
+				context = append(context, lines[i-1])
+			}
+		}
+		
+		compilerErr := console.CompilerError{
+			Position: console.ErrorPosition{
+				File:   filePath,
+				Line:   onLine,
+				Column: onColumn,
+			},
+			Type:    "error",
+			Message: fmt.Sprintf("trigger syntax error: %s", err.Error()),
+			Context: context,
+		}
+		
+		// Format and return the error
+		formattedErr := console.FormatError(compilerErr)
+		return errors.New(formattedErr)
+	}
+	
+	// Fallback to original error if we can't find the line
+	schedulePreprocessingLog.Printf("Could not find 'on:' line in frontmatter, using fallback error")
+	return fmt.Errorf("trigger syntax error: %w", err)
+}
+
 // addFriendlyScheduleComments adds comments showing the original friendly format for schedule cron expressions
 // This function is called after the YAML has been generated from the frontmatter
 func (c *Compiler) addFriendlyScheduleComments(yamlStr string, frontmatter map[string]any) string {
diff --git a/pkg/workflow/schedule_preprocessing_test.go b/pkg/workflow/schedule_preprocessing_test.go
index d14485c7e58..293e423b212 100644
--- a/pkg/workflow/schedule_preprocessing_test.go
+++ b/pkg/workflow/schedule_preprocessing_test.go
@@ -89,7 +89,7 @@ func TestSchedulePreprocessingShorthandOnString(t *testing.T) {
 			// (required for all schedule tests to avoid fuzzy schedule errors)
 			compiler.SetWorkflowIdentifier("test-workflow.md")
 
-			err := compiler.preprocessScheduleFields(tt.frontmatter)
+			err := compiler.preprocessScheduleFields(tt.frontmatter, "", "")
 
 			if tt.expectedError {
 				if err == nil {
@@ -332,7 +332,7 @@ func TestSchedulePreprocessing(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			compiler := NewCompiler(false, "", "test")
-			err := compiler.preprocessScheduleFields(tt.frontmatter)
+			err := compiler.preprocessScheduleFields(tt.frontmatter, "", "")
 
 			if tt.expectedError {
 				if err == nil {
@@ -378,7 +378,7 @@ func TestScheduleFriendlyComments(t *testing.T) {
 	compiler := NewCompiler(false, "", "test")
 
 	// Preprocess to convert and store friendly formats
-	err := compiler.preprocessScheduleFields(frontmatter)
+	err := compiler.preprocessScheduleFields(frontmatter, "", "")
 	if err != nil {
 		t.Fatalf("preprocessing failed: %v", err)
 	}
@@ -452,7 +452,7 @@ func TestFuzzyScheduleScattering(t *testing.T) {
 				compiler.SetWorkflowIdentifier(tt.workflowIdentifier)
 			}
 
-			err := compiler.preprocessScheduleFields(tt.frontmatter)
+			err := compiler.preprocessScheduleFields(tt.frontmatter, "", "")
 
 			if tt.expectError {
 				if err == nil {
@@ -510,7 +510,7 @@ func TestFuzzyScheduleScatteringDeterministic(t *testing.T) {
 		compiler := NewCompiler(false, "", "test")
 		compiler.SetWorkflowIdentifier(wf)
 
-		err := compiler.preprocessScheduleFields(frontmatter)
+		err := compiler.preprocessScheduleFields(frontmatter, "", "")
 		if err != nil {
 			t.Fatalf("unexpected error for workflow %s: %v", wf, err)
 		}
@@ -604,7 +604,7 @@ func TestSchedulePreprocessingWithFuzzyDaily(t *testing.T) {
 			compiler := NewCompiler(false, "", "test")
 			compiler.SetWorkflowIdentifier("test-workflow.md")
 
-			err := compiler.preprocessScheduleFields(tt.frontmatter)
+			err := compiler.preprocessScheduleFields(tt.frontmatter, "", "")
 
 			if tt.expectError {
 				if err == nil {
@@ -669,7 +669,7 @@ func TestSchedulePreprocessingDailyVariations(t *testing.T) {
 		},
 	}
 
-	err := compiler.preprocessScheduleFields(frontmatter)
+	err := compiler.preprocessScheduleFields(frontmatter, "", "")
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
@@ -760,7 +760,7 @@ func TestSlashCommandShorthand(t *testing.T) {
 			compiler := NewCompiler(false, "", "test")
 			compiler.SetWorkflowIdentifier("test-workflow.md")
 
-			err := compiler.preprocessScheduleFields(tt.frontmatter)
+			err := compiler.preprocessScheduleFields(tt.frontmatter, "", "")
 
 			if tt.expectedError {
 				if err == nil {
diff --git a/pkg/workflow/trigger_parser.go b/pkg/workflow/trigger_parser.go
new file mode 100644
index 00000000000..791c06a6566
--- /dev/null
+++ b/pkg/workflow/trigger_parser.go
@@ -0,0 +1,605 @@
+package workflow
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/githubnext/gh-aw/pkg/logger"
+)
+
+var triggerParserLog = logger.New("workflow:trigger_parser")
+
+// TriggerIR represents the intermediate representation of a parsed trigger
+type TriggerIR struct {
+	// Event is the main GitHub Actions event type (e.g., "push", "pull_request", "issues")
+	Event string
+
+	// Types contains the activity types for the event (e.g., ["opened", "edited"])
+	Types []string
+
+	// Filters contains additional event filters (branches, paths, tags, labels, etc.)
+	Filters map[string]any
+
+	// Conditions contains job-level conditions for complex filtering
+	Conditions []string
+
+	// AdditionalEvents contains other events to include (e.g., workflow_dispatch)
+	AdditionalEvents map[string]any
+}
+
+// ParseTriggerShorthand parses a human-readable trigger shorthand string
+// and returns a structured intermediate representation that can be converted to YAML.
+// Returns nil if the input is not a recognized trigger shorthand.
+func ParseTriggerShorthand(input string) (*TriggerIR, error) {
+	input = strings.TrimSpace(input)
+	if input == "" {
+		return nil, fmt.Errorf("trigger shorthand cannot be empty. Expected format: 'push to <branch>', 'issue opened', 'pull_request merged', etc.")
+	}
+
+	triggerParserLog.Printf("Parsing trigger shorthand: %s", input)
+
+	// Try parsers in order of specificity:
+
+	// 1. Slash command shorthand (starts with /)
+	if ir, err := parseSlashCommandTrigger(input); ir != nil || err != nil {
+		return ir, err
+	}
+
+	// 2. Label trigger shorthand (entity labeled label1 label2...)
+	if ir, err := parseLabelTrigger(input); ir != nil || err != nil {
+		return ir, err
+	}
+
+	// 3. Source control patterns (push, pull request, etc.)
+	if ir, err := parseSourceControlTrigger(input); ir != nil || err != nil {
+		return ir, err
+	}
+
+	// 4. Issue and discussion patterns
+	if ir, err := parseIssueDiscussionTrigger(input); ir != nil || err != nil {
+		return ir, err
+	}
+
+	// 5. Manual invocation patterns
+	if ir, err := parseManualTrigger(input); ir != nil || err != nil {
+		return ir, err
+	}
+
+	// 6. Comment patterns
+	if ir, err := parseCommentTrigger(input); ir != nil || err != nil {
+		return ir, err
+	}
+
+	// 7. Release and repository patterns
+	if ir, err := parseReleaseRepositoryTrigger(input); ir != nil || err != nil {
+		return ir, err
+	}
+
+	// 8. Security patterns
+	if ir, err := parseSecurityTrigger(input); ir != nil || err != nil {
+		return ir, err
+	}
+
+	// 9. External integration patterns
+	if ir, err := parseExternalTrigger(input); ir != nil || err != nil {
+		return ir, err
+	}
+
+	// Not a recognized trigger shorthand
+	return nil, nil
+}
+
+// ToYAMLMap converts a TriggerIR to a map structure suitable for YAML generation
+func (ir *TriggerIR) ToYAMLMap() map[string]any {
+	result := make(map[string]any)
+
+	// Add the main event
+	if ir.Event != "" {
+		eventConfig := make(map[string]any)
+
+		// Add types if specified
+		if len(ir.Types) > 0 {
+			eventConfig["types"] = ir.Types
+		}
+
+		// Add filters
+		for key, value := range ir.Filters {
+			eventConfig[key] = value
+		}
+
+		// If event config has content, add it; otherwise omit the event entirely for simple triggers
+		if len(eventConfig) > 0 {
+			result[ir.Event] = eventConfig
+		} else {
+			// For events with no configuration, use an empty map instead of nil
+			// This ensures proper YAML generation without "null" values
+			result[ir.Event] = map[string]any{}
+		}
+	}
+
+	// Add additional events
+	for event, config := range ir.AdditionalEvents {
+		result[event] = config
+	}
+
+	return result
+}
+
+// parseSlashCommandTrigger parses slash command triggers like "/test"
+func parseSlashCommandTrigger(input string) (*TriggerIR, error) {
+	commandName, isSlashCommand, err := parseSlashCommandShorthand(input)
+	if err != nil {
+		return nil, err
+	}
+	if !isSlashCommand {
+		return nil, nil
+	}
+
+	triggerParserLog.Printf("Parsed slash command trigger: %s", commandName)
+
+	// Note: slash_command is handled specially in the compiler, not as a standard GitHub event
+	// We return nil here to let the existing slash command processing handle it
+	return nil, nil
+}
+
+// parseLabelTrigger parses label triggers like "issue labeled bug" or "pull_request labeled needs-review"
+func parseLabelTrigger(input string) (*TriggerIR, error) {
+	entityType, labelNames, isLabelTrigger, err := parseLabelTriggerShorthand(input)
+	if err != nil {
+		return nil, err
+	}
+	if !isLabelTrigger {
+		return nil, nil
+	}
+
+	triggerParserLog.Printf("Parsed label trigger: %s labeled %v", entityType, labelNames)
+
+	// Note: Label triggers are handled specially via expandLabelTriggerShorthand
+	// We return nil here to let the existing label trigger processing handle it
+	return nil, nil
+}
+
+// parseSourceControlTrigger parses source control triggers
+func parseSourceControlTrigger(input string) (*TriggerIR, error) {
+	tokens := strings.Fields(input)
+	if len(tokens) == 0 {
+		return nil, nil
+	}
+
+	switch tokens[0] {
+	case "push":
+		return parsePushTrigger(tokens)
+	case "pull", "pull_request":
+		// Normalize "pull" to "pull_request"
+		normalizedTokens := append([]string{"pull_request"}, tokens[1:]...)
+		return parsePullRequestTrigger(normalizedTokens)
+	default:
+		return nil, nil
+	}
+}
+
+// parsePushTrigger parses push-related triggers
+func parsePushTrigger(tokens []string) (*TriggerIR, error) {
+	if len(tokens) == 1 {
+		// Simple "push" trigger - leave as simple string, don't convert
+		// GitHub Actions supports simple event names as strings: on: push
+		return nil, nil
+	}
+
+	if len(tokens) >= 3 && tokens[1] == "to" {
+		// "push to <branch>"
+		branch := strings.Join(tokens[2:], " ")
+		return &TriggerIR{
+			Event: "push",
+			Filters: map[string]any{
+				"branches": []string{branch},
+			},
+			AdditionalEvents: map[string]any{
+				"workflow_dispatch": nil,
+			},
+		}, nil
+	}
+
+	if len(tokens) >= 3 && tokens[1] == "tags" {
+		// "push tags <pattern>"
+		pattern := strings.Join(tokens[2:], " ")
+		return &TriggerIR{
+			Event: "push",
+			Filters: map[string]any{
+				"tags": []string{pattern},
+			},
+			AdditionalEvents: map[string]any{
+				"workflow_dispatch": nil,
+			},
+		}, nil
+	}
+
+	return nil, fmt.Errorf("invalid push trigger format: '%s'. Expected format: 'push to <branch>' or 'push tags <pattern>'. Example: 'push to main' or 'push tags v*'", strings.Join(tokens, " "))
+}
+
+// parsePullRequestTrigger parses pull request triggers
+func parsePullRequestTrigger(tokens []string) (*TriggerIR, error) {
+	if len(tokens) == 1 {
+		// Simple "pull_request" trigger - leave as simple string
+		// GitHub Actions supports: on: pull_request
+		return nil, nil
+	}
+
+	// Check for activity type: "pull_request opened", "pull_request merged", etc.
+	activityType := tokens[1]
+
+	// Map common activity types
+	validTypes := map[string]bool{
+		"opened":           true,
+		"edited":           true,
+		"closed":           true,
+		"reopened":         true,
+		"synchronize":      true,
+		"assigned":         true,
+		"unassigned":       true,
+		"labeled":          true,
+		"unlabeled":        true,
+		"review_requested": true,
+	}
+
+	// Special case: "merged" is not a real type, it's a condition on "closed"
+	if activityType == "merged" {
+		return &TriggerIR{
+			Event:      "pull_request",
+			Types:      []string{"closed"},
+			Conditions: []string{"github.event.pull_request.merged == true"},
+			AdditionalEvents: map[string]any{
+				"workflow_dispatch": nil,
+			},
+		}, nil
+	}
+
+	if validTypes[activityType] {
+		ir := &TriggerIR{
+			Event: "pull_request",
+			Types: []string{activityType},
+			AdditionalEvents: map[string]any{
+				"workflow_dispatch": nil,
+			},
+		}
+
+		// Check for path filter: "pull_request opened affecting <path>"
+		if len(tokens) >= 4 && tokens[2] == "affecting" {
+			path := strings.Join(tokens[3:], " ")
+			ir.Filters = map[string]any{
+				"paths": []string{path},
+			}
+		}
+
+		return ir, nil
+	}
+
+	// Check for "affecting" without activity type: "pull_request affecting <path>"
+	if activityType == "affecting" && len(tokens) >= 3 {
+		path := strings.Join(tokens[2:], " ")
+		return &TriggerIR{
+			Event: "pull_request",
+			Types: []string{"opened", "synchronize", "reopened"},
+			Filters: map[string]any{
+				"paths": []string{path},
+			},
+			AdditionalEvents: map[string]any{
+				"workflow_dispatch": nil,
+			},
+		}, nil
+	}
+
+	return nil, fmt.Errorf("invalid pull_request trigger format: '%s'. Expected format: 'pull_request <type>' or 'pull_request affecting <path>'. Valid types: opened, edited, closed, reopened, synchronize, merged, labeled, unlabeled. Example: 'pull_request opened' or 'pull_request affecting src/**'", strings.Join(tokens, " "))
+}
+
+// parseIssueDiscussionTrigger parses issue and discussion triggers
+func parseIssueDiscussionTrigger(input string) (*TriggerIR, error) {
+	tokens := strings.Fields(input)
+	if len(tokens) < 2 {
+		return nil, nil
+	}
+
+	switch tokens[0] {
+	case "issue":
+		return parseIssueTrigger(tokens)
+	case "discussion":
+		return parseDiscussionTrigger(tokens)
+	default:
+		return nil, nil
+	}
+}
+
+// parseIssueTrigger parses issue triggers
+func parseIssueTrigger(tokens []string) (*TriggerIR, error) {
+	if len(tokens) < 2 {
+		return nil, fmt.Errorf("issue trigger requires an activity type. Expected format: 'issue <type>'. Valid types: opened, edited, closed, reopened, assigned, unassigned, labeled, unlabeled, deleted, transferred. Example: 'issue opened'")
+	}
+
+	activityType := tokens[1]
+
+	// Map common activity types
+	validTypes := map[string]bool{
+		"opened":      true,
+		"edited":      true,
+		"closed":      true,
+		"reopened":    true,
+		"assigned":    true,
+		"unassigned":  true,
+		"labeled":     true,
+		"unlabeled":   true,
+		"deleted":     true,
+		"transferred": true,
+	}
+
+	if !validTypes[activityType] {
+		return nil, fmt.Errorf("invalid issue activity type: '%s'. Valid types: opened, edited, closed, reopened, assigned, unassigned, labeled, unlabeled, deleted, transferred. Example: 'issue opened'", activityType)
+	}
+
+	ir := &TriggerIR{
+		Event: "issues",
+		Types: []string{activityType},
+		AdditionalEvents: map[string]any{
+			"workflow_dispatch": nil,
+		},
+	}
+
+	// Check for label filter: "issue opened labeled <label>"
+	if len(tokens) >= 4 && tokens[2] == "labeled" {
+		label := strings.Join(tokens[3:], " ")
+		ir.Conditions = []string{
+			fmt.Sprintf("contains(github.event.issue.labels.*.name, '%s')", label),
+		}
+	}
+
+	return ir, nil
+}
+
+// parseDiscussionTrigger parses discussion triggers
+func parseDiscussionTrigger(tokens []string) (*TriggerIR, error) {
+	if len(tokens) < 2 {
+		return nil, fmt.Errorf("discussion trigger requires an activity type. Expected format: 'discussion <type>'. Valid types: created, edited, deleted, transferred, pinned, unpinned, labeled, unlabeled, locked, unlocked, category_changed, answered, unanswered. Example: 'discussion created'")
+	}
+
+	activityType := tokens[1]
+
+	// Map common activity types
+	validTypes := map[string]bool{
+		"created":          true,
+		"edited":           true,
+		"deleted":          true,
+		"transferred":      true,
+		"pinned":           true,
+		"unpinned":         true,
+		"labeled":          true,
+		"unlabeled":        true,
+		"locked":           true,
+		"unlocked":         true,
+		"category_changed": true,
+		"answered":         true,
+		"unanswered":       true,
+	}
+
+	if !validTypes[activityType] {
+		return nil, fmt.Errorf("invalid discussion activity type: '%s'. Valid types: created, edited, deleted, transferred, pinned, unpinned, labeled, unlabeled, locked, unlocked, category_changed, answered, unanswered. Example: 'discussion created'", activityType)
+	}
+
+	return &TriggerIR{
+		Event: "discussion",
+		Types: []string{activityType},
+		AdditionalEvents: map[string]any{
+			"workflow_dispatch": nil,
+		},
+	}, nil
+}
+
+// parseManualTrigger parses manual invocation triggers
+func parseManualTrigger(input string) (*TriggerIR, error) {
+	tokens := strings.Fields(input)
+	if len(tokens) == 0 {
+		return nil, nil
+	}
+
+	if tokens[0] == "manual" {
+		ir := &TriggerIR{
+			AdditionalEvents: map[string]any{
+				"workflow_dispatch": nil,
+			},
+		}
+
+		// Check for input specification: "manual with input <name>"
+		if len(tokens) >= 4 && tokens[1] == "with" && tokens[2] == "input" {
+			inputName := tokens[3]
+			ir.AdditionalEvents["workflow_dispatch"] = map[string]any{
+				"inputs": map[string]any{
+					inputName: map[string]any{
+						"description": fmt.Sprintf("Input for %s", inputName),
+						"required":    false,
+						"type":        "string",
+					},
+				},
+			}
+		}
+
+		return ir, nil
+	}
+
+	if len(tokens) >= 3 && tokens[0] == "workflow" && tokens[1] == "completed" {
+		// "workflow completed <workflow-name>"
+		workflowName := strings.Join(tokens[2:], " ")
+		return &TriggerIR{
+			Event: "workflow_run",
+			Types: []string{"completed"},
+			Filters: map[string]any{
+				"workflows": []string{workflowName},
+			},
+		}, nil
+	}
+
+	return nil, nil
+}
+
+// parseCommentTrigger parses comment triggers
+func parseCommentTrigger(input string) (*TriggerIR, error) {
+	tokens := strings.Fields(input)
+	if len(tokens) < 2 {
+		return nil, nil
+	}
+
+	if tokens[0] == "comment" && tokens[1] == "created" {
+		// "comment created" - supports both issue and PR comments
+		return &TriggerIR{
+			Event: "issue_comment",
+			Types: []string{"created"},
+			AdditionalEvents: map[string]any{
+				"workflow_dispatch": nil,
+			},
+		}, nil
+	}
+
+	return nil, nil
+}
+
+// parseReleaseRepositoryTrigger parses release and repository lifecycle triggers
+func parseReleaseRepositoryTrigger(input string) (*TriggerIR, error) {
+	tokens := strings.Fields(input)
+	if len(tokens) < 2 {
+		return nil, nil
+	}
+
+	switch tokens[0] {
+	case "release":
+		return parseReleaseTrigger(tokens)
+	case "repository":
+		return parseRepositoryTrigger(tokens)
+	default:
+		return nil, nil
+	}
+}
+
+// parseReleaseTrigger parses release triggers
+func parseReleaseTrigger(tokens []string) (*TriggerIR, error) {
+	if len(tokens) < 2 {
+		return nil, fmt.Errorf("release trigger requires an activity type. Expected format: 'release <type>'. Valid types: published, unpublished, created, edited, deleted, prereleased, released. Example: 'release published'")
+	}
+
+	activityType := tokens[1]
+
+	validTypes := map[string]bool{
+		"published":   true,
+		"unpublished": true,
+		"created":     true,
+		"edited":      true,
+		"deleted":     true,
+		"prereleased": true,
+		"released":    true,
+	}
+
+	if !validTypes[activityType] {
+		return nil, fmt.Errorf("invalid release activity type: '%s'. Valid types: published, unpublished, created, edited, deleted, prereleased, released. Example: 'release published'", activityType)
+	}
+
+	return &TriggerIR{
+		Event: "release",
+		Types: []string{activityType},
+		AdditionalEvents: map[string]any{
+			"workflow_dispatch": nil,
+		},
+	}, nil
+}
+
+// parseRepositoryTrigger parses repository lifecycle triggers
+func parseRepositoryTrigger(tokens []string) (*TriggerIR, error) {
+	if len(tokens) < 2 {
+		return nil, fmt.Errorf("repository trigger requires an activity type. Expected format: 'repository <type>'. Valid types: starred, forked. Example: 'repository starred'")
+	}
+
+	activityType := tokens[1]
+
+	// Map activity types to events
+	switch activityType {
+	case "starred":
+		// GitHub Actions uses "watch" event for starring
+		return &TriggerIR{
+			Event: "watch",
+			Types: []string{"started"},
+			AdditionalEvents: map[string]any{
+				"workflow_dispatch": nil,
+			},
+		}, nil
+	case "forked":
+		return &TriggerIR{
+			Event:   "fork",
+			Filters: map[string]any{}, // Empty map to avoid null in YAML
+			AdditionalEvents: map[string]any{
+				"workflow_dispatch": nil,
+			},
+		}, nil
+	default:
+		return nil, fmt.Errorf("invalid repository activity type: '%s'. Valid types: starred, forked. Example: 'repository starred'", activityType)
+	}
+}
+
+// parseSecurityTrigger parses security-related triggers
+func parseSecurityTrigger(input string) (*TriggerIR, error) {
+	tokens := strings.Fields(input)
+	if len(tokens) < 2 {
+		return nil, nil
+	}
+
+	if tokens[0] == "dependabot" && len(tokens) >= 3 && tokens[1] == "pull" && tokens[2] == "request" {
+		// "dependabot pull request" - filter pull requests by Dependabot author
+		return &TriggerIR{
+			Event:      "pull_request",
+			Types:      []string{"opened", "synchronize", "reopened"},
+			Conditions: []string{"github.actor == 'dependabot[bot]'"},
+			AdditionalEvents: map[string]any{
+				"workflow_dispatch": nil,
+			},
+		}, nil
+	}
+
+	if tokens[0] == "security" && tokens[1] == "alert" {
+		// "security alert" - code scanning alert
+		return &TriggerIR{
+			Event: "code_scanning_alert",
+			Types: []string{"created", "reopened", "fixed"},
+			AdditionalEvents: map[string]any{
+				"workflow_dispatch": nil,
+			},
+		}, nil
+	}
+
+	if len(tokens) >= 3 && tokens[0] == "code" && tokens[1] == "scanning" && tokens[2] == "alert" {
+		// "code scanning alert" - explicit code scanning alert
+		return &TriggerIR{
+			Event: "code_scanning_alert",
+			Types: []string{"created", "reopened", "fixed"},
+			AdditionalEvents: map[string]any{
+				"workflow_dispatch": nil,
+			},
+		}, nil
+	}
+
+	return nil, nil
+}
+
+// parseExternalTrigger parses external integration triggers
+func parseExternalTrigger(input string) (*TriggerIR, error) {
+	tokens := strings.Fields(input)
+	if len(tokens) < 3 {
+		return nil, nil
+	}
+
+	if tokens[0] == "api" && tokens[1] == "dispatch" {
+		// "api dispatch <event-type>"
+		eventType := strings.Join(tokens[2:], " ")
+		return &TriggerIR{
+			Event: "repository_dispatch",
+			Filters: map[string]any{
+				"types": []string{eventType},
+			},
+		}, nil
+	}
+
+	return nil, nil
+}
diff --git a/pkg/workflow/trigger_parser_fuzz_test.go b/pkg/workflow/trigger_parser_fuzz_test.go
new file mode 100644
index 00000000000..d8cc5696944
--- /dev/null
+++ b/pkg/workflow/trigger_parser_fuzz_test.go
@@ -0,0 +1,398 @@
+package workflow
+
+import (
+	"strings"
+	"testing"
+)
+
+// FuzzParseTriggerShorthand is a fuzz test for the ParseTriggerShorthand function.
+// It validates that the parser handles arbitrary input gracefully without panicking,
+// and that it produces consistent, valid output for recognized trigger patterns.
+//
+// The fuzzer validates that:
+// 1. The parser never panics on any input
+// 2. Error handling is consistent (error implies nil result)
+// 3. Valid triggers produce well-formed TriggerIR structures
+// 4. Event types are from the expected set of GitHub Actions events
+// 5. Filter structures are valid when present
+// 6. Additional events are properly formatted
+// 7. Edge cases (empty strings, very long inputs, special characters) are handled
+func FuzzParseTriggerShorthand(f *testing.F) {
+	// Seed corpus with valid trigger patterns
+
+	// Source Control Patterns
+	f.Add("push to main")
+	f.Add("push to develop")
+	f.Add("push to feature/test")
+	f.Add("push tags v*")
+	f.Add("push tags v1.*")
+	f.Add("pull_request opened")
+	f.Add("pull_request synchronize")
+	f.Add("pull_request reopened")
+	f.Add("pull_request closed")
+	f.Add("pull_request merged")
+	f.Add("pull_request labeled")
+	f.Add("pull_request affecting src/**")
+	f.Add("pull_request affecting docs/*.md")
+	f.Add("pull_request opened affecting src/**.go")
+	f.Add("pull opened")
+	f.Add("pull synchronize")
+
+	// Issue Patterns
+	f.Add("issue opened")
+	f.Add("issue edited")
+	f.Add("issue closed")
+	f.Add("issue reopened")
+	f.Add("issue assigned")
+	f.Add("issue unassigned")
+	f.Add("issue labeled")
+	f.Add("issue unlabeled")
+	f.Add("issue deleted")
+	f.Add("issue transferred")
+	f.Add("issue opened labeled bug")
+	f.Add("issue opened labeled enhancement")
+
+	// Discussion Patterns
+	f.Add("discussion created")
+	f.Add("discussion edited")
+	f.Add("discussion deleted")
+	f.Add("discussion transferred")
+	f.Add("discussion pinned")
+	f.Add("discussion unpinned")
+	f.Add("discussion labeled")
+	f.Add("discussion unlabeled")
+	f.Add("discussion locked")
+	f.Add("discussion unlocked")
+	f.Add("discussion category_changed")
+	f.Add("discussion answered")
+	f.Add("discussion unanswered")
+
+	// Manual Invocation Patterns
+	f.Add("manual")
+	f.Add("manual with input version")
+	f.Add("manual with input environment")
+	f.Add("manual with input tag")
+	f.Add("workflow completed ci-test")
+	f.Add("workflow completed build")
+	f.Add("workflow completed deploy-prod")
+
+	// Comment Patterns
+	f.Add("comment created")
+
+	// Release and Repository Patterns
+	f.Add("release published")
+	f.Add("release unpublished")
+	f.Add("release created")
+	f.Add("release edited")
+	f.Add("release deleted")
+	f.Add("release prereleased")
+	f.Add("release released")
+	f.Add("repository starred")
+	f.Add("repository forked")
+
+	// Security Patterns
+	f.Add("dependabot pull request")
+	f.Add("security alert")
+	f.Add("code scanning alert")
+
+	// External Integration Patterns
+	f.Add("api dispatch deploy-staging")
+	f.Add("api dispatch custom-event")
+	f.Add("api dispatch build-triggered")
+
+	// Case variations
+	f.Add("PUSH TO MAIN")
+	f.Add("Pull_Request Opened")
+	f.Add("Issue Created")
+	f.Add("MANUAL")
+
+	// Invalid/Edge Cases that should handle gracefully
+
+	// Empty and whitespace
+	f.Add("")
+	f.Add("   ")
+	f.Add("\t\n")
+	f.Add("\r\n")
+
+	// Unrecognized patterns
+	f.Add("random text here")
+	f.Add("not a trigger")
+	f.Add("some random input")
+	f.Add("123456789")
+
+	// Incomplete patterns
+	f.Add("push")
+	f.Add("pull_request")
+	f.Add("issue")
+	f.Add("discussion")
+	f.Add("release")
+	f.Add("repository")
+	f.Add("push to")
+	f.Add("push tags")
+	f.Add("pull_request affecting")
+	f.Add("issue opened labeled")
+	f.Add("manual with input")
+	f.Add("workflow completed")
+	f.Add("api dispatch")
+
+	// Invalid activity types
+	f.Add("issue invalid_type")
+	f.Add("pull_request invalid_type")
+	f.Add("discussion invalid_type")
+	f.Add("release invalid_type")
+
+	// Malformed patterns
+	f.Add("push to to main")
+	f.Add("push tags tags v*")
+	f.Add("pull_request opened opened")
+	f.Add("issue opened closed")
+	f.Add("manual manual")
+	f.Add("repository starred forked")
+
+	// Very long strings
+	longString := strings.Repeat("a", 10000)
+	f.Add(longString)
+	f.Add("push to " + longString)
+	f.Add("issue opened " + longString)
+	f.Add("manual with input " + longString)
+
+	// Special characters
+	f.Add("push to main\x00")
+	f.Add("issue opened\n\r")
+	f.Add("pull_request;echo hack")
+	f.Add("manual' OR '1'='1")
+	f.Add("push to main<script>alert(1)</script>")
+	f.Add("issue opened$(whoami)")
+	f.Add("push to main`id`")
+
+	// Unicode characters
+	f.Add("push to メイン")
+	f.Add("issue 开放")
+	f.Add("manual avec entrée version")
+
+	// Multiple spaces and tabs
+	f.Add("push  to  main")
+	f.Add("push\tto\tmain")
+	f.Add("issue   opened")
+	f.Add("pull_request   opened   affecting   src/**")
+
+	// Mixed patterns
+	f.Add("push to main pull_request opened")
+	f.Add("issue opened discussion created")
+	f.Add("manual release published")
+
+	// Numeric edge cases
+	f.Add("workflow completed 2147483647")
+	f.Add("api dispatch " + strings.Repeat("x", 1000))
+
+	// Path/branch with special characters
+	f.Add("push to feat/new-feature")
+	f.Add("push to release/v1.0.0")
+	f.Add("push to hotfix/urgent-fix")
+	f.Add("pull_request affecting src/**/test_*.go")
+	f.Add("pull_request affecting .github/workflows/*.yml")
+
+	// Run the fuzzer
+	f.Fuzz(func(t *testing.T, input string) {
+		// The parser should never panic regardless of input
+		ir, err := ParseTriggerShorthand(input)
+
+		// Validate output consistency
+		if err != nil {
+			// On error, IR should be nil
+			if ir != nil {
+				t.Errorf("ParseTriggerShorthand returned non-nil IR with error for input: %q, error: %v", input, err)
+			}
+
+			// Error message should not be empty
+			if err.Error() == "" {
+				t.Errorf("ParseTriggerShorthand returned error with empty message for input: %q", input)
+			}
+
+			// Error should not be generic
+			if err.Error() == "error" {
+				t.Errorf("ParseTriggerShorthand returned generic 'error' message for input: %q", input)
+			}
+		}
+
+		// If IR is returned, validate its structure
+		if ir != nil {
+			validateTriggerIR(t, ir, input)
+		}
+
+		// For empty input, should return an error
+		if strings.TrimSpace(input) == "" && err == nil && ir != nil {
+			t.Errorf("ParseTriggerShorthand should error on empty input, but returned IR: %v", ir)
+		}
+
+		// Validate that recognized patterns produce IR
+		if looksLikeValidTrigger(input) && err == nil && ir == nil {
+			// This might be a simple trigger like "push" or "pull_request" that returns nil
+			// This is acceptable behavior
+			_ = input
+		}
+	})
+}
+
+// FuzzTriggerIRToYAMLMap is a fuzz test for the ToYAMLMap method.
+// It validates that the YAML map generation handles various IR structures correctly.
+func FuzzTriggerIRToYAMLMap(f *testing.F) {
+	// Seed with valid IR structures
+	f.Add("push", "")
+	f.Add("pull_request", "opened,synchronize")
+	f.Add("issues", "opened")
+	f.Add("discussion", "created")
+	f.Add("release", "published")
+	f.Add("watch", "started")
+	f.Add("fork", "")
+	f.Add("issue_comment", "created")
+	f.Add("workflow_run", "completed")
+	f.Add("repository_dispatch", "")
+	f.Add("code_scanning_alert", "created")
+
+	f.Fuzz(func(t *testing.T, event string, typesStr string) {
+		// Parse types from comma-separated string
+		var types []string
+		if typesStr != "" {
+			for _, typ := range strings.Split(typesStr, ",") {
+				typ = strings.TrimSpace(typ)
+				if typ != "" {
+					types = append(types, typ)
+				}
+			}
+		}
+
+		// Create IR
+		ir := &TriggerIR{
+			Event: event,
+			Types: types,
+			Filters: map[string]any{
+				"branches": []string{"main"},
+			},
+			AdditionalEvents: map[string]any{
+				"workflow_dispatch": nil,
+			},
+		}
+
+		// ToYAMLMap should never panic
+		result := ir.ToYAMLMap()
+
+		// Validate result structure
+		if result == nil {
+			t.Error("ToYAMLMap returned nil")
+			return
+		}
+
+		// If event is non-empty, it should be in the result
+		if event != "" {
+			if _, hasEvent := result[event]; !hasEvent {
+				t.Errorf("ToYAMLMap result missing event %q", event)
+			}
+		}
+
+		// Additional events should be present
+		if _, hasDispatch := result["workflow_dispatch"]; !hasDispatch {
+			t.Error("ToYAMLMap result missing workflow_dispatch")
+		}
+	})
+}
+
+// validateTriggerIR validates that a TriggerIR structure is well-formed
+func validateTriggerIR(t *testing.T, ir *TriggerIR, input string) {
+	// Event should be from the expected set of GitHub Actions events
+	validEvents := map[string]bool{
+		"push":                 true,
+		"pull_request":         true,
+		"issues":               true,
+		"discussion":           true,
+		"release":              true,
+		"watch":                true,
+		"fork":                 true,
+		"issue_comment":        true,
+		"workflow_run":         true,
+		"repository_dispatch":  true,
+		"code_scanning_alert":  true,
+		"":                     true, // Empty is valid for manual-only triggers
+	}
+
+	if !validEvents[ir.Event] {
+		t.Errorf("TriggerIR has unexpected event type %q for input: %q", ir.Event, input)
+	}
+
+	// Types should not contain empty strings
+	for i, typ := range ir.Types {
+		if typ == "" {
+			t.Errorf("TriggerIR.Types[%d] is empty for input: %q", i, input)
+		}
+	}
+
+	// Filters should be a valid map
+	if ir.Filters != nil {
+		for key, value := range ir.Filters {
+			if key == "" {
+				t.Errorf("TriggerIR.Filters has empty key for input: %q", input)
+			}
+			if value == nil {
+				t.Errorf("TriggerIR.Filters[%q] is nil for input: %q", key, input)
+			}
+		}
+	}
+
+	// Conditions should not contain empty strings
+	for i, cond := range ir.Conditions {
+		if cond == "" {
+			t.Errorf("TriggerIR.Conditions[%d] is empty for input: %q", i, input)
+		}
+	}
+
+	// AdditionalEvents should be a valid map
+	if ir.AdditionalEvents != nil {
+		for key := range ir.AdditionalEvents {
+			if key == "" {
+				t.Errorf("TriggerIR.AdditionalEvents has empty key for input: %q", input)
+			}
+		}
+	}
+
+	// Validate that if Event is empty, AdditionalEvents should have something
+	if ir.Event == "" && (ir.AdditionalEvents == nil || len(ir.AdditionalEvents) == 0) {
+		t.Errorf("TriggerIR has empty Event but no AdditionalEvents for input: %q", input)
+	}
+}
+
+// looksLikeValidTrigger returns true if the input looks like it might be a valid trigger pattern
+func looksLikeValidTrigger(input string) bool {
+	input = strings.TrimSpace(strings.ToLower(input))
+
+	if input == "" {
+		return false
+	}
+
+	// Check for valid pattern prefixes
+	validPrefixes := []string{
+		"push to",
+		"push tags",
+		"pull_request",
+		"pull ",
+		"issue ",
+		"discussion ",
+		"manual",
+		"workflow completed",
+		"comment created",
+		"release ",
+		"repository starred",
+		"repository forked",
+		"dependabot pull request",
+		"security alert",
+		"code scanning alert",
+		"api dispatch",
+	}
+
+	for _, prefix := range validPrefixes {
+		if strings.HasPrefix(input, prefix) {
+			return true
+		}
+	}
+
+	return false
+}
diff --git a/pkg/workflow/trigger_parser_test.go b/pkg/workflow/trigger_parser_test.go
new file mode 100644
index 00000000000..507743a04a5
--- /dev/null
+++ b/pkg/workflow/trigger_parser_test.go
@@ -0,0 +1,558 @@
+package workflow
+
+import (
+	"testing"
+)
+
+func TestParseTriggerShorthand(t *testing.T) {
+	tests := []struct {
+		name        string
+		input       string
+		wantEvent   string
+		wantTypes   []string
+		wantFilters map[string]any
+		wantConds   []string
+		wantNil     bool
+		wantErr     bool
+	}{
+		// Source Control Patterns - Push
+		{
+			name:    "simple push (left as-is)",
+			input:   "push",
+			wantNil: true, // Simple triggers left as-is
+		},
+		{
+			name:      "push to branch",
+			input:     "push to main",
+			wantEvent: "push",
+			wantFilters: map[string]any{
+				"branches": []string{"main"},
+			},
+		},
+		{
+			name:      "push to branch with spaces",
+			input:     "push to feature branch",
+			wantEvent: "push",
+			wantFilters: map[string]any{
+				"branches": []string{"feature branch"},
+			},
+		},
+		{
+			name:      "push tags",
+			input:     "push tags v*",
+			wantEvent: "push",
+			wantFilters: map[string]any{
+				"tags": []string{"v*"},
+			},
+		},
+
+		// Source Control Patterns - Pull Request
+		{
+			name:    "simple pull_request (left as-is)",
+			input:   "pull_request",
+			wantNil: true, // Simple triggers left as-is
+		},
+		{
+			name:    "simple pull (left as-is)",
+			input:   "pull",
+			wantNil: true, // Simple triggers left as-is
+		},
+		{
+			name:      "pull_request opened",
+			input:     "pull_request opened",
+			wantEvent: "pull_request",
+			wantTypes: []string{"opened"},
+		},
+		{
+			name:      "pull_request merged",
+			input:     "pull_request merged",
+			wantEvent: "pull_request",
+			wantTypes: []string{"closed"},
+			wantConds: []string{"github.event.pull_request.merged == true"},
+		},
+		{
+			name:      "pull_request affecting path",
+			input:     "pull_request affecting src/**.go",
+			wantEvent: "pull_request",
+			wantTypes: []string{"opened", "synchronize", "reopened"},
+			wantFilters: map[string]any{
+				"paths": []string{"src/**.go"},
+			},
+		},
+		{
+			name:      "pull_request opened affecting path",
+			input:     "pull_request opened affecting docs/**",
+			wantEvent: "pull_request",
+			wantTypes: []string{"opened"},
+			wantFilters: map[string]any{
+				"paths": []string{"docs/**"},
+			},
+		},
+
+		// Issue Patterns
+		{
+			name:      "issue opened",
+			input:     "issue opened",
+			wantEvent: "issues",
+			wantTypes: []string{"opened"},
+		},
+		{
+			name:      "issue edited",
+			input:     "issue edited",
+			wantEvent: "issues",
+			wantTypes: []string{"edited"},
+		},
+		{
+			name:      "issue closed",
+			input:     "issue closed",
+			wantEvent: "issues",
+			wantTypes: []string{"closed"},
+		},
+		{
+			name:      "issue opened labeled bug",
+			input:     "issue opened labeled bug",
+			wantEvent: "issues",
+			wantTypes: []string{"opened"},
+			wantConds: []string{"contains(github.event.issue.labels.*.name, 'bug')"},
+		},
+
+		// Discussion Patterns
+		{
+			name:      "discussion created",
+			input:     "discussion created",
+			wantEvent: "discussion",
+			wantTypes: []string{"created"},
+		},
+		{
+			name:      "discussion edited",
+			input:     "discussion edited",
+			wantEvent: "discussion",
+			wantTypes: []string{"edited"},
+		},
+
+		// Manual Invocation Patterns
+		{
+			name:    "manual",
+			input:   "manual",
+			wantNil: false, // Returns IR with only workflow_dispatch
+		},
+		{
+			name:    "manual with input",
+			input:   "manual with input version",
+			wantNil: false,
+		},
+		{
+			name:      "workflow completed",
+			input:     "workflow completed ci-test",
+			wantEvent: "workflow_run",
+			wantTypes: []string{"completed"},
+			wantFilters: map[string]any{
+				"workflows": []string{"ci-test"},
+			},
+		},
+
+		// Comment Patterns
+		{
+			name:      "comment created",
+			input:     "comment created",
+			wantEvent: "issue_comment",
+			wantTypes: []string{"created"},
+		},
+
+		// Release Patterns
+		{
+			name:      "release published",
+			input:     "release published",
+			wantEvent: "release",
+			wantTypes: []string{"published"},
+		},
+		{
+			name:      "release prereleased",
+			input:     "release prereleased",
+			wantEvent: "release",
+			wantTypes: []string{"prereleased"},
+		},
+
+		// Repository Patterns
+		{
+			name:      "repository starred",
+			input:     "repository starred",
+			wantEvent: "watch",
+			wantTypes: []string{"started"},
+		},
+		{
+			name:      "repository forked",
+			input:     "repository forked",
+			wantEvent: "fork",
+		},
+
+		// Security Patterns
+		{
+			name:      "dependabot pull request",
+			input:     "dependabot pull request",
+			wantEvent: "pull_request",
+			wantTypes: []string{"opened", "synchronize", "reopened"},
+			wantConds: []string{"github.actor == 'dependabot[bot]'"},
+		},
+		{
+			name:      "security alert",
+			input:     "security alert",
+			wantEvent: "code_scanning_alert",
+			wantTypes: []string{"created", "reopened", "fixed"},
+		},
+		{
+			name:      "code scanning alert",
+			input:     "code scanning alert",
+			wantEvent: "code_scanning_alert",
+			wantTypes: []string{"created", "reopened", "fixed"},
+		},
+
+		// External Integration Patterns
+		{
+			name:      "api dispatch",
+			input:     "api dispatch custom-event",
+			wantEvent: "repository_dispatch",
+			wantFilters: map[string]any{
+				"types": []string{"custom-event"},
+			},
+		},
+
+		// Invalid/Unrecognized Patterns
+		{
+			name:    "not a trigger shorthand",
+			input:   "some random text",
+			wantNil: true,
+		},
+		{
+			name:    "empty string",
+			input:   "",
+			wantErr: true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			ir, err := ParseTriggerShorthand(tt.input)
+
+			if tt.wantErr {
+				if err == nil {
+					t.Errorf("ParseTriggerShorthand() expected error but got none")
+				}
+				return
+			}
+
+			if err != nil {
+				t.Errorf("ParseTriggerShorthand() unexpected error = %v", err)
+				return
+			}
+
+			if tt.wantNil {
+				if ir != nil {
+					t.Errorf("ParseTriggerShorthand() expected nil but got IR with event %s", ir.Event)
+				}
+				return
+			}
+
+			if ir == nil {
+				t.Errorf("ParseTriggerShorthand() returned nil when IR was expected")
+				return
+			}
+
+			if ir.Event != tt.wantEvent {
+				t.Errorf("ParseTriggerShorthand() event = %v, want %v", ir.Event, tt.wantEvent)
+			}
+
+			if !slicesEqual(ir.Types, tt.wantTypes) {
+				t.Errorf("ParseTriggerShorthand() types = %v, want %v", ir.Types, tt.wantTypes)
+			}
+
+			if !mapsEqual(ir.Filters, tt.wantFilters) {
+				t.Errorf("ParseTriggerShorthand() filters = %v, want %v", ir.Filters, tt.wantFilters)
+			}
+
+			if !slicesEqual(ir.Conditions, tt.wantConds) {
+				t.Errorf("ParseTriggerShorthand() conditions = %v, want %v", ir.Conditions, tt.wantConds)
+			}
+		})
+	}
+}
+
+func TestTriggerIRToYAMLMap(t *testing.T) {
+	tests := []struct {
+		name string
+		ir   *TriggerIR
+		want map[string]any
+	}{
+		{
+			name: "simple event",
+			ir: &TriggerIR{
+				Event: "push",
+			},
+			want: map[string]any{
+				"push": map[string]any{}, // Empty map instead of nil to avoid null in YAML
+			},
+		},
+		{
+			name: "event with types",
+			ir: &TriggerIR{
+				Event: "issues",
+				Types: []string{"opened", "edited"},
+			},
+			want: map[string]any{
+				"issues": map[string]any{
+					"types": []string{"opened", "edited"},
+				},
+			},
+		},
+		{
+			name: "event with filters",
+			ir: &TriggerIR{
+				Event: "push",
+				Filters: map[string]any{
+					"branches": []string{"main"},
+				},
+			},
+			want: map[string]any{
+				"push": map[string]any{
+					"branches": []string{"main"},
+				},
+			},
+		},
+		{
+			name: "event with additional events",
+			ir: &TriggerIR{
+				Event: "push",
+				AdditionalEvents: map[string]any{
+					"workflow_dispatch": nil,
+				},
+			},
+			want: map[string]any{
+				"push":              map[string]any{}, // Empty map instead of nil
+				"workflow_dispatch": nil,
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := tt.ir.ToYAMLMap()
+
+			if !mapsEqual(got, tt.want) {
+				t.Errorf("TriggerIR.ToYAMLMap() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func TestParseSourceControlTriggers(t *testing.T) {
+	tests := []struct {
+		name      string
+		input     string
+		wantEvent string
+		wantTypes []string
+		wantErr   bool
+	}{
+		{
+			name:      "pull_request with synchronize",
+			input:     "pull_request synchronize",
+			wantEvent: "pull_request",
+			wantTypes: []string{"synchronize"},
+		},
+		{
+			name:      "pull_request with reopened",
+			input:     "pull_request reopened",
+			wantEvent: "pull_request",
+			wantTypes: []string{"reopened"},
+		},
+		{
+			name:      "pull_request with labeled",
+			input:     "pull_request labeled",
+			wantEvent: "pull_request",
+			wantTypes: []string{"labeled"},
+		},
+		{
+			name:    "invalid push format",
+			input:   "push invalid format",
+			wantErr: true,
+		},
+		{
+			name:    "invalid pull_request type",
+			input:   "pull_request invalid",
+			wantErr: true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			ir, err := ParseTriggerShorthand(tt.input)
+
+			if tt.wantErr {
+				if err == nil {
+					t.Errorf("ParseTriggerShorthand() expected error but got none")
+				}
+				return
+			}
+
+			if err != nil {
+				t.Errorf("ParseTriggerShorthand() unexpected error = %v", err)
+				return
+			}
+
+			if ir == nil {
+				t.Errorf("ParseTriggerShorthand() returned nil")
+				return
+			}
+
+			if ir.Event != tt.wantEvent {
+				t.Errorf("Event = %v, want %v", ir.Event, tt.wantEvent)
+			}
+
+			if !slicesEqual(ir.Types, tt.wantTypes) {
+				t.Errorf("Types = %v, want %v", ir.Types, tt.wantTypes)
+			}
+		})
+	}
+}
+
+func TestParseIssueDiscussionTriggers(t *testing.T) {
+	tests := []struct {
+		name      string
+		input     string
+		wantEvent string
+		wantTypes []string
+		wantErr   bool
+	}{
+		{
+			name:      "issue assigned",
+			input:     "issue assigned",
+			wantEvent: "issues",
+			wantTypes: []string{"assigned"},
+		},
+		{
+			name:      "issue unassigned",
+			input:     "issue unassigned",
+			wantEvent: "issues",
+			wantTypes: []string{"unassigned"},
+		},
+		{
+			name:      "discussion answered",
+			input:     "discussion answered",
+			wantEvent: "discussion",
+			wantTypes: []string{"answered"},
+		},
+		{
+			name:      "discussion unanswered",
+			input:     "discussion unanswered",
+			wantEvent: "discussion",
+			wantTypes: []string{"unanswered"},
+		},
+		{
+			name:    "invalid issue type",
+			input:   "issue invalid",
+			wantErr: true,
+		},
+		{
+			name:    "invalid discussion type",
+			input:   "discussion invalid",
+			wantErr: true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			ir, err := ParseTriggerShorthand(tt.input)
+
+			if tt.wantErr {
+				if err == nil {
+					t.Errorf("ParseTriggerShorthand() expected error but got none")
+				}
+				return
+			}
+
+			if err != nil {
+				t.Errorf("ParseTriggerShorthand() unexpected error = %v", err)
+				return
+			}
+
+			if ir == nil {
+				t.Errorf("ParseTriggerShorthand() returned nil")
+				return
+			}
+
+			if ir.Event != tt.wantEvent {
+				t.Errorf("Event = %v, want %v", ir.Event, tt.wantEvent)
+			}
+
+			if !slicesEqual(ir.Types, tt.wantTypes) {
+				t.Errorf("Types = %v, want %v", ir.Types, tt.wantTypes)
+			}
+		})
+	}
+}
+
+// Helper function to compare maps
+func mapsEqual(a, b map[string]any) bool {
+	if len(a) != len(b) {
+		return false
+	}
+
+	for key, aVal := range a {
+		bVal, exists := b[key]
+		if !exists {
+			return false
+		}
+
+		// Handle nil values
+		if aVal == nil && bVal == nil {
+			continue
+		}
+		if aVal == nil || bVal == nil {
+			return false
+		}
+
+		// Handle map values
+		if aMap, ok := aVal.(map[string]any); ok {
+			if bMap, ok := bVal.(map[string]any); ok {
+				if !mapsEqual(aMap, bMap) {
+					return false
+				}
+				continue
+			}
+			return false
+		}
+
+		// Handle slice values
+		if aSlice, ok := aVal.([]string); ok {
+			if bSlice, ok := bVal.([]string); ok {
+				if !slicesEqual(aSlice, bSlice) {
+					return false
+				}
+				continue
+			}
+			return false
+		}
+
+		// Handle []any values
+		if aSlice, ok := aVal.([]any); ok {
+			if bSlice, ok := bVal.([]any); ok {
+				if len(aSlice) != len(bSlice) {
+					return false
+				}
+				for i := range aSlice {
+					if aSlice[i] != bSlice[i] {
+						return false
+					}
+				}
+				continue
+			}
+			return false
+		}
+
+		// Direct comparison for other types
+		if aVal != bVal {
+			return false
+		}
+	}
+
+	return true
+}
diff --git a/pkg/workflow/trigger_shorthand_integration_test.go b/pkg/workflow/trigger_shorthand_integration_test.go
new file mode 100644
index 00000000000..79040359099
--- /dev/null
+++ b/pkg/workflow/trigger_shorthand_integration_test.go
@@ -0,0 +1,314 @@
+package workflow
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func TestTriggerShorthandIntegration(t *testing.T) {
+	tests := []struct {
+		name           string
+		markdown       string
+		wantTrigger    string
+		wantNoCompile  bool
+		wantErrContain string
+	}{
+		{
+			name: "push trigger shorthand",
+			markdown: `---
+on: push
+---
+# Test Workflow
+Test workflow for push trigger`,
+			wantTrigger: `"on": push`,
+		},
+		{
+			name: "push to branch shorthand",
+			markdown: `---
+on: push to main
+---
+# Test Workflow
+Test workflow for push to branch`,
+			wantTrigger: "branches:",
+		},
+		{
+			name: "pull_request shorthand",
+			markdown: `---
+on: pull_request
+---
+# Test Workflow
+Test workflow for pull request`,
+			wantTrigger: `"on": pull_request`,
+		},
+		{
+			name: "pull_request opened shorthand",
+			markdown: `---
+on: pull_request opened
+---
+# Test Workflow
+Test workflow for pull request opened`,
+			wantTrigger: "types:",
+		},
+		{
+			name: "issue opened shorthand",
+			markdown: `---
+on: issue opened
+---
+# Test Workflow
+Test workflow for issue opened`,
+			wantTrigger: "issues:",
+		},
+		{
+			name: "discussion created shorthand",
+			markdown: `---
+on: discussion created
+---
+# Test Workflow
+Test workflow for discussion created`,
+			wantTrigger: "discussion:",
+		},
+		{
+			name: "release published shorthand",
+			markdown: `---
+on: release published
+---
+# Test Workflow
+Test workflow for release published`,
+			wantTrigger: "release:",
+		},
+		{
+			name: "repository starred shorthand",
+			markdown: `---
+on: repository starred
+---
+# Test Workflow
+Test workflow for repository starred`,
+			wantTrigger: "watch:",
+		},
+		{
+			name: "comment created shorthand",
+			markdown: `---
+on: comment created
+---
+# Test Workflow
+Test workflow for comment created`,
+			wantTrigger: "issue_comment:",
+		},
+		{
+			name: "manual shorthand",
+			markdown: `---
+on: manual
+---
+# Test Workflow
+Test workflow for manual dispatch`,
+			wantTrigger: "workflow_dispatch:",
+		},
+		{
+			name: "dependabot pull request shorthand",
+			markdown: `---
+on: dependabot pull request
+---
+# Test Workflow
+Test workflow for dependabot PRs`,
+			wantTrigger: "pull_request:",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			// Create a temporary directory for this test
+			tmpDir := t.TempDir()
+			mdFile := filepath.Join(tmpDir, "test.md")
+			lockFile := filepath.Join(tmpDir, "test.lock.yml")
+
+			// Write the markdown to a file
+			if err := os.WriteFile(mdFile, []byte(tt.markdown), 0644); err != nil {
+				t.Fatalf("Failed to write test markdown: %v", err)
+			}
+
+			c := NewCompiler(false, "", "test")
+
+			err := c.CompileWorkflow(mdFile)
+
+			if tt.wantNoCompile {
+				if err == nil {
+					t.Errorf("Expected compilation to fail but it succeeded")
+				}
+				if tt.wantErrContain != "" && !strings.Contains(err.Error(), tt.wantErrContain) {
+					t.Errorf("Error message should contain %q but got: %s", tt.wantErrContain, err.Error())
+				}
+				return
+			}
+
+			if err != nil {
+				t.Fatalf("Unexpected compilation error: %v", err)
+			}
+
+			// Read the generated lock file
+			yamlOutput, err := os.ReadFile(lockFile)
+			if err != nil {
+				t.Fatalf("Failed to read lock file: %v", err)
+			}
+
+			yamlStr := string(yamlOutput)
+
+			if !strings.Contains(yamlStr, tt.wantTrigger) {
+				t.Errorf("Compiled YAML should contain %q\nGot:\n%s", tt.wantTrigger, yamlStr)
+			}
+
+			if tt.wantTrigger == `"on": push` || tt.wantTrigger == `"on": pull_request` {
+				// Simple triggers remain as-is, no workflow_dispatch added
+				return
+			}
+
+			// Verify workflow_dispatch is added for most triggers
+			if tt.wantTrigger != "workflow_dispatch:" && tt.name != "manual shorthand" {
+				if !strings.Contains(yamlStr, "workflow_dispatch:") {
+					t.Errorf("Compiled YAML should include workflow_dispatch\nGot:\n%s", yamlStr)
+				}
+			}
+		})
+	}
+}
+
+func TestTriggerShorthandWithFilters(t *testing.T) {
+	tests := []struct {
+		name        string
+		markdown    string
+		wantContain []string
+	}{
+		{
+			name: "push to main with branch filter",
+			markdown: `---
+on: push to main
+---
+# Test Workflow
+Test`,
+			wantContain: []string{
+				"push:",
+				"branches:",
+				"- main",
+			},
+		},
+		{
+			name: "push tags with pattern",
+			markdown: `---
+on: push tags v*
+---
+# Test Workflow
+Test`,
+			wantContain: []string{
+				"push:",
+				"tags:",
+				"- v*",
+			},
+		},
+		{
+			name: "pull_request affecting path",
+			markdown: `---
+on: pull_request affecting src/**.go
+---
+# Test Workflow
+Test`,
+			wantContain: []string{
+				"pull_request:",
+				"paths:",
+				"- src/**.go",
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			// Create a temporary directory for this test
+			tmpDir := t.TempDir()
+			mdFile := filepath.Join(tmpDir, "test.md")
+			lockFile := filepath.Join(tmpDir, "test.lock.yml")
+
+			// Write the markdown to a file
+			if err := os.WriteFile(mdFile, []byte(tt.markdown), 0644); err != nil {
+				t.Fatalf("Failed to write test markdown: %v", err)
+			}
+
+			c := NewCompiler(false, "", "test")
+
+			err := c.CompileWorkflow(mdFile)
+			if err != nil {
+				t.Fatalf("Unexpected compilation error: %v", err)
+			}
+
+			// Read the generated lock file
+			yamlOutput, err := os.ReadFile(lockFile)
+			if err != nil {
+				t.Fatalf("Failed to read lock file: %v", err)
+			}
+
+			yamlStr := string(yamlOutput)
+
+			for _, want := range tt.wantContain {
+				if !strings.Contains(yamlStr, want) {
+					t.Errorf("Compiled YAML should contain %q\nGot:\n%s", want, yamlStr)
+				}
+			}
+		})
+	}
+}
+
+func TestTriggerShorthandBackwardCompatibility(t *testing.T) {
+	// Test that existing trigger formats still work
+	tests := []struct {
+		name     string
+		markdown string
+	}{
+		{
+			name: "slash command shorthand",
+			markdown: `---
+on: /test
+---
+# Test
+Test`,
+		},
+		{
+			name: "label trigger shorthand",
+			markdown: `---
+on: issue labeled bug
+---
+# Test
+Test`,
+		},
+		{
+			name: "traditional YAML format with object",
+			markdown: `---
+on:
+  push:
+    branches: [main]
+  pull_request:
+    types: [opened]
+---
+# Test
+Test`,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			// Create a temporary directory for this test
+			tmpDir := t.TempDir()
+			mdFile := filepath.Join(tmpDir, "test.md")
+
+			// Write the markdown to a file
+			if err := os.WriteFile(mdFile, []byte(tt.markdown), 0644); err != nil {
+				t.Fatalf("Failed to write test markdown: %v", err)
+			}
+
+			c := NewCompiler(false, "", "test")
+
+			err := c.CompileWorkflow(mdFile)
+			if err != nil {
+				t.Errorf("Backward compatibility broken: %v", err)
+			}
+		})
+	}
+}