fix: use frontmatter hash instead of mtime to determine compiled status in gh aw list (#25364)

Author: Copilot

pkg/cli/list_workflows_command.go

@@ -133,6 +133,9 @@ func RunListWorkflows(repo, path, pattern string, verbose bool, jsonOutput bool,
 	// Build workflow list
 	var workflows []WorkflowListItem
 
+	// Shared import cache across all iterations to avoid re-creating it for every workflow
+	importCache := parser.NewImportCache("")
+
 	for _, file := range mdFiles {
 		name := extractWorkflowNameFromPath(file)
 
@@ -161,14 +164,7 @@ func RunListWorkflows(repo, path, pattern string, verbose bool, jsonOutput bool,
 			compiled := "N/A"
 
 			if _, err := os.Stat(lockFile); err == nil {
-				// Check if up to date
-				mdStat, _ := os.Stat(file)
-				lockStat, _ := os.Stat(lockFile)
-				if mdStat.ModTime().After(lockStat.ModTime()) {
-					compiled = "No"
-				} else {
-					compiled = "Yes"
-				}
+				compiled = isCompiledUpToDateWithCache(file, lockFile, importCache)
 			}
 
 			// Extract "on" field and labels from frontmatter

pkg/cli/list_workflows_command_test.go

@@ -3,11 +3,14 @@
 package cli
 
 import (
+	"bytes"
 	"encoding/json"
+	"io"
 	"os"
 	"path/filepath"
 	"testing"
 
+	"github.com/github/gh-aw/pkg/parser"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
@@ -120,3 +123,88 @@ func TestNewListCommand(t *testing.T) {
 	labelFlag := cmd.Flags().Lookup("label")
 	assert.NotNil(t, labelFlag, "Command should have --label flag")
 }
+
+// captureListOutput calls RunListWorkflows and returns the captured stdout as a string.
+func captureListOutput(t *testing.T, dir, pattern string) string {
+	t.Helper()
+	oldStdout := os.Stdout
+	r, w, err := os.Pipe()
+	require.NoError(t, err, "Should create pipe")
+	os.Stdout = w
+
+	runErr := RunListWorkflows("", dir, pattern, false, true, "")
+
+	w.Close()
+	os.Stdout = oldStdout
+
+	var buf bytes.Buffer
+	_, _ = io.Copy(&buf, r)
+	require.NoError(t, runErr, "RunListWorkflows should not error")
+	return buf.String()
+}
+
+func TestRunListWorkflows_CompiledField(t *testing.T) {
+	tmpDir := t.TempDir()
+
+	// Minimal valid workflow markdown
+	mdContent := `---
+name: test-workflow
+on:
+  workflow_dispatch:
+engine: copilot
+---
+
+# Test Workflow
+
+A simple test workflow.
+`
+	mdPath := filepath.Join(tmpDir, "test-workflow.md")
+	require.NoError(t, os.WriteFile(mdPath, []byte(mdContent), 0644), "Should write test workflow")
+
+	// Compute the real frontmatter hash
+	cache := parser.NewImportCache("")
+	realHash, err := parser.ComputeFrontmatterHashFromFile(mdPath, cache)
+	require.NoError(t, err, "Should compute frontmatter hash")
+
+	t.Run("compiled Yes when hash matches", func(t *testing.T) {
+		lockPath := filepath.Join(tmpDir, "test-workflow.lock.yml")
+		lockContent := `# gh-aw-metadata: {"schema_version":"v1","frontmatter_hash":"` + realHash + `"}
+name: test-workflow
+`
+		require.NoError(t, os.WriteFile(lockPath, []byte(lockContent), 0644), "Should write lock file")
+
+		output := captureListOutput(t, tmpDir, "")
+
+		var items []WorkflowListItem
+		require.NoError(t, json.Unmarshal([]byte(output), &items), "Should unmarshal JSON output")
+		require.Len(t, items, 1, "Should have one workflow")
+		assert.Equal(t, "Yes", items[0].Compiled, "Compiled should be Yes when hash matches")
+	})
+
+	t.Run("compiled No when hash mismatches", func(t *testing.T) {
+		lockPath := filepath.Join(tmpDir, "test-workflow.lock.yml")
+		lockContent := `# gh-aw-metadata: {"schema_version":"v1","frontmatter_hash":"0000000000000000000000000000000000000000000000000000000000000000"}
+name: test-workflow
+`
+		require.NoError(t, os.WriteFile(lockPath, []byte(lockContent), 0644), "Should write lock file with wrong hash")
+
+		output := captureListOutput(t, tmpDir, "")
+
+		var items []WorkflowListItem
+		require.NoError(t, json.Unmarshal([]byte(output), &items), "Should unmarshal JSON output")
+		require.Len(t, items, 1, "Should have one workflow")
+		assert.Equal(t, "No", items[0].Compiled, "Compiled should be No when hash mismatches")
+	})
+
+	t.Run("compiled NA when no lock file", func(t *testing.T) {
+		// Remove lock file
+		_ = os.Remove(filepath.Join(tmpDir, "test-workflow.lock.yml"))
+
+		output := captureListOutput(t, tmpDir, "")
+
+		var items []WorkflowListItem
+		require.NoError(t, json.Unmarshal([]byte(output), &items), "Should unmarshal JSON output")
+		require.Len(t, items, 1, "Should have one workflow")
+		assert.Equal(t, "N/A", items[0].Compiled, "Compiled should be N/A when no lock file exists")
+	})
+}

pkg/cli/status_command.go

@@ -266,6 +266,13 @@ func calculateTimeRemaining(stopTimeStr string) string {
 // isCompiledUpToDate checks if a workflow's lock file is up to date with the current source
 // using hash-based comparison. Falls back to "Yes" when no hash is available (legacy lock files).
 func isCompiledUpToDate(workflowPath, lockFilePath string) string {
+	return isCompiledUpToDateWithCache(workflowPath, lockFilePath, parser.NewImportCache(""))
+}
+
+// isCompiledUpToDateWithCache is the same as isCompiledUpToDate but accepts a shared
+// ImportCache so callers that check multiple workflows can avoid creating a new cache
+// on every call.
+func isCompiledUpToDateWithCache(workflowPath, lockFilePath string, cache *parser.ImportCache) string {
 	lockContent, err := os.ReadFile(lockFilePath)
 	if err != nil {
 		return "No"
@@ -277,7 +284,6 @@ func isCompiledUpToDate(workflowPath, lockFilePath string) string {
 		return "Yes"
 	}
 
-	cache := parser.NewImportCache("")
 	currentHash, err := parser.ComputeFrontmatterHashFromFile(workflowPath, cache)
 	if err != nil {
 		statusLog.Printf("Failed to compute frontmatter hash for %s: %v", workflowPath, err)