logs: keep paging in all-workflows mode when full batches filter to zero runs

pkg/cli/logs_github_api.go

@@ -167,20 +167,23 @@ func fetchJobDetails(runID int64, verbose bool) ([]JobInfoWithDuration, error) {
 
 // ListWorkflowRunsOptions holds the options for listWorkflowRunsWithPagination
 type ListWorkflowRunsOptions struct {
-	Context        context.Context
-	WorkflowName   string // filter by specific workflow (if empty, fetches all agentic workflows)
-	Status         string // filter by run status/conclusion (for example: completed, success, failure)
-	Limit          int    // maximum number of runs to fetch in this API call (batch size)
-	StartDate      string // filter by creation date (>=); combined with EndDate/BeforeDate into a single --created range
-	EndDate        string // filter by creation date (<=); combined with StartDate into a single --created range
-	BeforeDate     string // exclusive upper bound used for pagination (<); combined with StartDate into a single --created range
-	Ref            string // filter by branch or tag name
-	BeforeRunID    int64  // filter by run database ID (< this ID)
-	AfterRunID     int64  // filter by run database ID (> this ID)
-	RepoOverride   string // fetch from a specific repository instead of current
-	ProcessedCount int    // number of runs already processed (for progress display)
-	TargetCount    int    // target number of runs to fetch (for progress display)
-	Verbose        bool   // enable verbose logging
+	Context      context.Context
+	WorkflowName string // filter by specific workflow (if empty, fetches all agentic workflows)
+	Status       string // filter by run status/conclusion (for example: completed, success, failure)
+	Limit        int    // maximum number of runs to fetch in this API call (batch size)
+	StartDate    string // filter by creation date (>=); combined with EndDate/BeforeDate into a single --created range
+	EndDate      string // filter by creation date (<=); combined with StartDate into a single --created range
+	BeforeDate   string // exclusive upper bound used for pagination (<); combined with StartDate into a single --created range
+	Ref          string // filter by branch or tag name
+	BeforeRunID  int64  // filter by run database ID (< this ID)
+	AfterRunID   int64  // filter by run database ID (> this ID)
+	RepoOverride string // fetch from a specific repository instead of current
+	// OldestFetchedCreatedAt, when set, is populated with the oldest run creation
+	// timestamp returned by GitHub in this batch before any workflow/conclusion filtering.
+	OldestFetchedCreatedAt *time.Time
+	ProcessedCount         int  // number of runs already processed (for progress display)
+	TargetCount            int  // target number of runs to fetch (for progress display)
+	Verbose                bool // enable verbose logging
 }
 
 // listWorkflowRunsWithPagination fetches workflow runs from GitHub Actions using the GitHub CLI.
@@ -319,6 +322,13 @@ func listWorkflowRunsWithPagination(opts ListWorkflowRunsOptions) ([]WorkflowRun
 
 	// Store the total count fetched from API before filtering
 	totalFetched := len(runs)
+	if opts.OldestFetchedCreatedAt != nil {
+		var oldest time.Time
+		if totalFetched > 0 {
+			oldest = runs[totalFetched-1].CreatedAt
+		}
+		*opts.OldestFetchedCreatedAt = oldest
+	}
 
 	// Filter only agentic workflow runs when no specific workflow is specified
 	// If a workflow name was specified, we already filtered by it in the API call

pkg/cli/logs_orchestrator.go

@@ -63,6 +63,20 @@ type LogsDownloadOptions struct {
 	After             string
 }
 
+func shouldStopPagination(totalFetched, batchSize int) bool {
+	return totalFetched < batchSize
+}
+
+func selectPaginationCursorDate(filteredRuns []WorkflowRun, oldestFetchedCreatedAt time.Time) (string, bool) {
+	if !oldestFetchedCreatedAt.IsZero() {
+		return oldestFetchedCreatedAt.Format(time.RFC3339), true
+	}
+	if len(filteredRuns) == 0 {
+		return "", false
+	}
+	return filteredRuns[len(filteredRuns)-1].CreatedAt.Format(time.RFC3339), true
+}
+
 // DownloadWorkflowLogs downloads and analyzes workflow logs with metrics
 func DownloadWorkflowLogs(ctx context.Context, opts LogsDownloadOptions) error {
 	workflowName := opts.WorkflowName
@@ -239,29 +253,47 @@ func DownloadWorkflowLogs(ctx context.Context, opts LogsDownloadOptions) error {
 			}
 		}
 
+		var oldestFetchedCreatedAt time.Time
 		runs, totalFetched, err := listWorkflowRunsWithPagination(ListWorkflowRunsOptions{
-			WorkflowName:   workflowName,
-			Limit:          batchSize,
-			StartDate:      startDate,
-			EndDate:        endDate,
-			BeforeDate:     beforeDate,
-			Ref:            ref,
-			BeforeRunID:    beforeRunID,
-			AfterRunID:     afterRunID,
-			RepoOverride:   repoOverride,
-			ProcessedCount: len(processedRuns),
-			TargetCount:    count,
-			Verbose:        verbose,
+			WorkflowName:           workflowName,
+			Limit:                  batchSize,
+			StartDate:              startDate,
+			EndDate:                endDate,
+			BeforeDate:             beforeDate,
+			Ref:                    ref,
+			BeforeRunID:            beforeRunID,
+			AfterRunID:             afterRunID,
+			RepoOverride:           repoOverride,
+			OldestFetchedCreatedAt: &oldestFetchedCreatedAt,
+			ProcessedCount:         len(processedRuns),
+			TargetCount:            count,
+			Verbose:                verbose,
 		})
 		if err != nil {
 			return err
 		}
 
 		if len(runs) == 0 {
+			if shouldStopPagination(totalFetched, batchSize) {
+				if verbose {
+					fmt.Fprintln(os.Stderr, console.FormatInfoMessage("No more workflow runs found, stopping iteration"))
+				}
+				break
+			}
+
+			cursor, ok := selectPaginationCursorDate(nil, oldestFetchedCreatedAt)
+			if !ok {
+				if verbose {
+					fmt.Fprintln(os.Stderr, console.FormatWarningMessage("Workflow batch filtered to zero runs but no pagination cursor was found, stopping iteration"))
+				}
+				break
+			}
+
+			beforeDate = cursor
 			if verbose {
-				fmt.Fprintln(os.Stderr, console.FormatInfoMessage("No more workflow runs found, stopping iteration"))
+				fmt.Fprintln(os.Stderr, console.FormatInfoMessage("Batch filtered to zero runs; advancing pagination cursor and continuing"))
 			}
-			break
+			continue
 		}
 
 		if verbose {
@@ -515,10 +547,12 @@ func DownloadWorkflowLogs(ctx context.Context, opts LogsDownloadOptions) error {
 			}
 		}
 
-		// Prepare for next iteration: set beforeDate to the oldest processed run from this batch
-		if len(runs) > 0 && len(runsRemaining) == 0 {
-			oldestRun := runs[len(runs)-1] // runs are typically ordered by creation date descending
-			beforeDate = oldestRun.CreatedAt.Format(time.RFC3339)
+		// Prepare for next iteration: set beforeDate to the oldest run from the raw API batch.
+		// This guarantees pagination moves forward even when filtered runs are sparse.
+		if len(runsRemaining) == 0 {
+			if cursor, ok := selectPaginationCursorDate(runs, oldestFetchedCreatedAt); ok {
+				beforeDate = cursor
+			}
 		}
 
 		// If we got fewer runs than requested in this batch, we've likely hit the end
@@ -528,7 +562,7 @@ func DownloadWorkflowLogs(ctx context.Context, opts LogsDownloadOptions) error {
 		// Example: API returns 250 total runs, but only 5 are agentic workflows after filtering.
 		//   Old buggy logic: len(runs)=5 < batchSize=250, stop iteration (WRONG - misses more agentic workflows!)
 		//   Fixed logic: totalFetched=250 < batchSize=250 is false, continue iteration (CORRECT)
-		if totalFetched < batchSize {
+		if shouldStopPagination(totalFetched, batchSize) {
 			if verbose {
 				fmt.Fprintln(os.Stderr, console.FormatInfoMessage("Received fewer runs than requested, likely reached end of available runs"))
 			}

pkg/cli/logs_orchestrator_pagination_test.go

@@ -0,0 +1,77 @@
+//go:build !integration
+
+package cli
+
+import (
+	"testing"
+	"time"
+)
+
+func TestShouldStopPagination(t *testing.T) {
+	tests := []struct {
+		name         string
+		totalFetched int
+		batchSize    int
+		want         bool
+	}{
+		{
+			name:         "stop when raw batch is smaller than requested",
+			totalFetched: 249,
+			batchSize:    250,
+			want:         true,
+		},
+		{
+			name:         "continue when raw batch is full",
+			totalFetched: 250,
+			batchSize:    250,
+			want:         false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := shouldStopPagination(tt.totalFetched, tt.batchSize); got != tt.want {
+				t.Fatalf("shouldStopPagination(%d, %d) = %v, want %v", tt.totalFetched, tt.batchSize, got, tt.want)
+			}
+		})
+	}
+}
+
+func TestSelectPaginationCursorDate(t *testing.T) {
+	oldestFetched := time.Date(2026, 6, 16, 10, 0, 0, 0, time.UTC)
+	filteredRuns := []WorkflowRun{
+		{CreatedAt: time.Date(2026, 6, 16, 12, 0, 0, 0, time.UTC)},
+		{CreatedAt: time.Date(2026, 6, 16, 11, 0, 0, 0, time.UTC)},
+	}
+
+	cursor, ok := selectPaginationCursorDate(filteredRuns, oldestFetched)
+	if !ok {
+		t.Fatal("expected cursor to be set when raw oldest fetched run is available")
+	}
+	if cursor != oldestFetched.Format(time.RFC3339) {
+		t.Fatalf("expected cursor %s, got %s", oldestFetched.Format(time.RFC3339), cursor)
+	}
+}
+
+func TestSelectPaginationCursorDateFallsBackToFilteredRuns(t *testing.T) {
+	filteredOldest := time.Date(2026, 6, 15, 18, 30, 0, 0, time.UTC)
+	filteredRuns := []WorkflowRun{
+		{CreatedAt: time.Date(2026, 6, 15, 19, 0, 0, 0, time.UTC)},
+		{CreatedAt: filteredOldest},
+	}
+
+	cursor, ok := selectPaginationCursorDate(filteredRuns, time.Time{})
+	if !ok {
+		t.Fatal("expected cursor to be set from filtered runs")
+	}
+	if cursor != filteredOldest.Format(time.RFC3339) {
+		t.Fatalf("expected fallback cursor %s, got %s", filteredOldest.Format(time.RFC3339), cursor)
+	}
+}
+
+func TestSelectPaginationCursorDateNoCursor(t *testing.T) {
+	cursor, ok := selectPaginationCursorDate(nil, time.Time{})
+	if ok {
+		t.Fatalf("expected no cursor, got %s", cursor)
+	}
+}