nx affected should recompute affected set when dependentTasksOutputFiles change during execution

[Hoffs]

Current Behavior

When using dependentTasksOutputFiles as task inputs, nx affected computes the affected project set upfront based on the current state of output files on disk. Tasks that depend on outputs produced by other tasks in the same run are not included in the affected set, even though their input hashes will differ once upstream tasks complete.

This means that for a dependency chain like:

Go service (build) → TF module A (apply, outputs tfoutputs.sha1) → TF module B (apply, depends on A's tfoutputs.sha1)

You need N+1 invocations of nx affected to fully converge:

1. Run 1: Go build runs, produces new bootstrap.zip
2. Run 2: TF apply A is now affected (bootstrap hash changed), produces new tfoutputs.sha1
3. Run 3: TF apply B is now affected (tfoutputs hash changed)
4. Run N+1: No more affected tasks

Expected Behavior

nx affected should be able to recompute the affected set after tasks complete and their outputs change, within a single invocation. Since task hashes are already computed lazily (right before execution, per #22623), the remaining gap is that the affected set itself is not re-evaluated when dependentTasksOutputFiles on disk change during the run.

Example Configuration

// nx.json targetDefaults
"nx-tf:apply": {
  "dependsOn": ["^build", "^apply", "initialize"],
  "inputs": [
    "production",
    // These are the problematic inputs — they reference outputs
    // that don't exist yet or will change during the run
    { "dependentTasksOutputFiles": "dist/**/bootstrap*", "transitive": false },
    { "dependentTasksOutputFiles": "dist/**/tfoutputs.sha1", "transitive": false },
    { "externalDependencies": [] }
  ],
  "outputs": ["{workspaceRoot}/dist/{projectRoot}/tfoutputs.sha1"],
  "cache": true
}

Workarounds

1. Add ^production to inputs — propagates affectedness via source files, making everything affected in a single pass. But this is imprecise: downstream tasks re-run even when upstream outputs are identical (e.g., a comment change in Go source triggers TF apply).

2. Loop nx affected in a shell script until no tasks remain — works but is fragile and slow (repeated graph computation, cache lookups, etc.).

Suggested Solution

When nx affected runs tasks that produce outputs listed in other tasks' dependentTasksOutputFiles, re-evaluate the affected set for remaining (not-yet-executed) tasks. This could be:

• Automatic: after any task with declared outputs completes, check if pending tasks' dependentTasksOutputFiles inputs have changed and add them to the affected set.
• Opt-in flag: e.g., nx affected -t apply --recompute-affected to enable this behavior.

This would make dependentTasksOutputFiles a complete replacement for ^production in dependency chains, without sacrificing cache precision.

[FrozenPandaz]

Thanks for the detailed proposal! We use GitHub Discussions for feature requests so they can be upvoted and discussed by the community. This has been moved to a discussion where it can be tracked and voted on.