fix(core): only detect flaky tasks for cacheable tasks (#33994)

AgentEnder · claude · web-flow · commit 5e4dd04b6657 · 2026-02-06T15:39:43.000-05:00
## Current Behavior Flaky task detection warns about all tasks that have different exit codes for the same hash, including non-cacheable tasks. This is misleading because the flaky task warning message points users to Nx Cloud's flaky task retry feature, which is only relevant for cached tasks. ## Expected Behavior Flaky task detection should only consider tasks where `task.cache === true`, making the warning more meaningful and avoiding noise for non-cacheable tasks. ## Related Issue(s) N/A - Internal improvement ## Changes Made ### `packages/nx/src/tasks-runner/life-cycles/task-history-life-cycle.ts` 1. Added `cacheable: boolean` to the `TaskRun` interface 2. In `endTasks`, now tracks `cacheable: taskResult.task.cache === true` for each task 3. In `endCommand`, filters to only check flaky tasks among cacheable tasks ### `packages/nx/src/tasks-runner/life-cycles/task-history-life-cycle-old.ts` 1. Added `cacheableHashes: Set<string>` to track which task hashes are cacheable 2. In `endTasks`, tracks cacheable tasks by adding their hash to the set 3. In `endCommand`, only checks for flaky tasks among cacheable task hashes 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-authored-by: Claude Opus 4.5 <noreply@anthropic.com>
diff --git a/packages/nx/src/tasks-runner/life-cycles/task-history-life-cycle-old.ts b/packages/nx/src/tasks-runner/life-cycles/task-history-life-cycle-old.ts
@@ -16,31 +16,47 @@ export class LegacyTaskHistoryLifeCycle implements LifeCycle {
   private taskRuns: TaskRun[] = [];
   private flakyTasks: string[];
 
+  // hashes which could trigger flaky task detection.
+  // set here rather than on the TaskRun to avoid storing data on
+  // the fs
+  private cacheableHashes: Set<string> = new Set();
+
   startTasks(tasks: Task[]): void {
     for (let task of tasks) {
       this.startTimings[task.id] = new Date().getTime();
     }
   }
 
   async endTasks(taskResults: TaskResult[]) {
-    const taskRuns: TaskRun[] = taskResults.map((taskResult) => ({
-      project: taskResult.task.target.project,
-      target: taskResult.task.target.target,
-      configuration: taskResult.task.target.configuration,
-      hash: taskResult.task.hash,
-      code: taskResult.code.toString(),
-      status: taskResult.status,
-      start: (
-        taskResult.task.startTime ?? this.startTimings[taskResult.task.id]
-      ).toString(),
-      end: (taskResult.task.endTime ?? new Date().getTime()).toString(),
-    }));
-    this.taskRuns.push(...taskRuns);
+    for (const taskResult of taskResults) {
+      // Track cacheable tasks for flaky detection
+      if (taskResult.task.cache === true) {
+        this.cacheableHashes.add(taskResult.task.hash);
+      }
+      this.taskRuns.push({
+        project: taskResult.task.target.project,
+        target: taskResult.task.target.target,
+        configuration: taskResult.task.target.configuration,
+        hash: taskResult.task.hash,
+        code: taskResult.code.toString(),
+        status: taskResult.status,
+        start: (
+          taskResult.task.startTime ?? this.startTimings[taskResult.task.id]
+        ).toString(),
+        end: (taskResult.task.endTime ?? new Date().getTime()).toString(),
+      });
+    }
   }
 
   async endCommand() {
     await writeTaskRunsToHistory(this.taskRuns);
-    const history = await getHistoryForHashes(this.taskRuns.map((t) => t.hash));
+    // Only check for flaky tasks among cacheable tasks
+    const cacheableTaskRuns = this.taskRuns.filter((t) =>
+      this.cacheableHashes.has(t.hash)
+    );
+    const history = await getHistoryForHashes(
+      cacheableTaskRuns.map((t) => t.hash)
+    );
     this.flakyTasks = [];
 
     // check if any hash has different exit codes => flaky
diff --git a/packages/nx/src/tasks-runner/life-cycles/task-history-life-cycle.ts b/packages/nx/src/tasks-runner/life-cycles/task-history-life-cycle.ts
@@ -11,6 +11,7 @@ import { LegacyTaskHistoryLifeCycle } from './task-history-life-cycle-old';
 
 interface TaskRun extends NativeTaskRun {
   target: Task['target'];
+  cacheable: boolean;
 }
 
 let tasksHistoryLifeCycle: TaskHistoryLifeCycle | LegacyTaskHistoryLifeCycle;
@@ -49,30 +50,41 @@ export class TaskHistoryLifeCycle implements LifeCycle {
   }
 
   async endTasks(taskResults: TaskResult[]) {
-    taskResults
-      .map((taskResult) => ({
+    for (const taskResult of taskResults) {
+      this.taskRuns.set(taskResult.task.hash, {
         hash: taskResult.task.hash,
         target: taskResult.task.target,
         code: taskResult.code,
         status: taskResult.status,
         start:
           taskResult.task.startTime ?? this.startTimings[taskResult.task.id],
         end: taskResult.task.endTime ?? Date.now(),
-      }))
-      .forEach((taskRun) => {
-        this.taskRuns.set(taskRun.hash, taskRun);
+        cacheable: taskResult.task.cache === true,
       });
+    }
   }
 
   async endCommand() {
-    const entries = Array.from(this.taskRuns);
     if (!this.taskHistory) {
       return;
     }
-    await this.taskHistory.recordTaskRuns(entries.map(([_, v]) => v));
-    this.flakyTasks = await this.taskHistory.getFlakyTasks(
-      entries.map(([hash]) => hash)
-    );
+    const runs = [];
+
+    // Only check for flaky tasks among cacheable tasks
+    const cacheableHashes: string[] = [];
+    const iterator = this.taskRuns.entries();
+    for (const [hash, run] of iterator) {
+      runs.push(run);
+      if (run.cacheable) {
+        cacheableHashes.push(hash);
+      }
+    }
+    await this.taskHistory.recordTaskRuns(runs);
+
+    this.flakyTasks =
+      cacheableHashes.length > 0
+        ? await this.taskHistory.getFlakyTasks(cacheableHashes)
+        : [];
     // Do not directly print output when using the TUI
     if (isTuiEnabled()) {
       return;
