fix(core): batch-safe hashing for maven and gradle

e2e/maven/src/maven-batch-v4.test.ts

@@ -66,8 +66,6 @@ wrapperUrl=https://repo.maven.apache.org/maven2/org/apache/maven/wrapper/maven-w
   });
 
   it('should fail when unit test fails', () => {
-    // TODO: remove once batch mode dependentTaskOutputs is fixed
-    runCLI('reset');
     // Add a failing unit test
     updateFile(
       'app/src/test/java/com/example/app/AppApplicationTests.java',

e2e/maven/src/utils/create-maven-project.ts

@@ -3,6 +3,7 @@ import {
   tmpProjPath,
   readFile,
   updateFile,
+  fileExists,
 } from '@nx/e2e-utils';
 import { execSync } from 'child_process';
 import { writeFileSync } from 'fs-extra';
@@ -155,6 +156,11 @@ export async function createMavenProject(
     '.mvn/wrapper/maven-wrapper.properties',
     readFile('app/.mvn/wrapper/maven-wrapper.properties')
   );
+  if (fileExists('.gitignore')) {
+    updateFile('.gitignore', readFile('.gitignore') + '\ntarget');
+  } else {
+    updateFile('.gitignore', 'target');
+  }
 
   chmodSync(join(cwd, 'mvnw'), 0o755);
   chmodSync(join(cwd, 'mvnw.cmd'), 0o755);

packages/maven/maven-plugin/src/main/kotlin/dev/nx/maven/cache/CacheConfig.kt

@@ -10,7 +10,7 @@ data class Parameter(val name: String, val glob: String?)
 data class MojoConfig(
     val inputProperties: Set<String>? = null,
     val inputParameters: Set<Parameter>? = null,
-    val outputParameters: Set<Parameter>? = null
+    val outputParameters: Set<Parameter>? = null,
 )
 
 /**
@@ -81,7 +81,7 @@ data class CacheConfig(
                 ),
                 "maven-compiler-plugin:testCompile" to MojoConfig(
                     inputParameters = setOf(
-                        Parameter("testCompileSourceRoots", "**/*.java"),
+                        Parameter("compileSourceRoots", "**/*.java"),
                     ),
                     outputParameters = setOf(
                         Parameter("outputDirectory", null),

packages/maven/maven-plugin/src/main/kotlin/dev/nx/maven/targets/NxTargetFactory.kt

@@ -614,10 +614,10 @@ class NxTargetFactory(
     val isIgnored = gitIgnoreClassifier.isIgnored(buildJsonFile)
     if (isIgnored) {
       log.warn("Input path is gitignored: ${buildJsonFile.path}")
-      val input = pathFormatter.toDependentTaskOutputs(buildJsonFile, project.basedir)
+      // Match the specific build state file in dependency outputs
       val obj = JsonObject()
-      obj.addProperty("dependentTasksOutputFiles", input.path)
-      if (input.transitive) obj.addProperty("transitive", true)
+      obj.addProperty("dependentTasksOutputFiles", "nx-build-state.json")
+      obj.addProperty("transitive", true)
       target.inputs?.add(obj)
     } else {
       val input = pathFormatter.formatInputPath(buildJsonFile, projectRoot = project.basedir)

packages/maven/maven-plugin/src/main/kotlin/dev/nx/maven/utils/MavenExpressionResolver.kt

@@ -15,16 +15,6 @@ class MavenExpressionResolver(
     private val log: Logger = LoggerFactory.getLogger(MavenExpressionResolver::class.java)
 
     fun resolveParameter(parameter: Parameter, project: MavenProject): List<String> {
-        // For compileSourceRoots and testCompileSourceRoots, always use collection handling
-        // to include ALL source roots (including generated sources)
-        if (parameter.name in setOf("compileSourceRoots", "testCompileSourceRoots")) {
-            return when (parameter.name) {
-                "compileSourceRoots" -> project.compileSourceRoots ?: emptyList()
-                "testCompileSourceRoots" -> project.testCompileSourceRoots ?: emptyList()
-                else -> emptyList()
-            }
-        }
-
         return when (parameter.type) {
             "java.io.File" -> listOfNotNull(
                 resolveStringParameterValue(

packages/maven/maven-plugin/src/main/kotlin/dev/nx/maven/utils/MojoAnalyzer.kt

@@ -83,15 +83,16 @@ class MojoAnalyzer(
       val paths = expressionResolver.resolveParameter(parameter, project)
 
       paths.forEach { path ->
-        val pathWithGlob = paramConfig.glob?.let { "$path/$it" } ?: path
-        val pathFile = File(pathWithGlob);
+        val pathFile = File(path)
         val isIgnored = gitIgnoreClassifier.isIgnored(pathFile)
         if (isIgnored) {
           log.warn("Input path is gitignored: ${pathFile.path}")
-          val input = pathResolver.toDependentTaskOutputs(pathFile, project.basedir)
-          dependentTaskOutputInputs.add(input)
+          // Use the parameter's glob pattern if provided, otherwise use **/*
+          val globPattern = paramConfig.glob ?: "**/*"
+          dependentTaskOutputInputs.add(DependentTaskOutputs(globPattern, transitive = true))
         } else {
-          val input = pathResolver.formatInputPath(pathFile, projectRoot = project.basedir)
+          val pathWithGlob = paramConfig.glob?.let { "$path/$it" } ?: path
+          val input = pathResolver.formatInputPath(File(pathWithGlob), projectRoot = project.basedir)
 
           inputs.add(input)
         }
@@ -106,8 +107,8 @@ class MojoAnalyzer(
         val isIgnored = gitIgnoreClassifier.isIgnored(pathFile)
         if (isIgnored) {
           log.warn("Input path is gitignored: ${pathFile.path}")
-          val input = pathResolver.toDependentTaskOutputs(pathFile, project.basedir)
-          dependentTaskOutputInputs.add(input)
+          // For properties, always use **/* pattern
+          dependentTaskOutputInputs.add(DependentTaskOutputs("**/*", transitive = true))
         } else {
           val input = pathResolver.formatInputPath(pathFile, projectRoot = project.basedir)
 
@@ -122,8 +123,8 @@ class MojoAnalyzer(
         val isIgnored = gitIgnoreClassifier.isIgnored(pathFile)
         if (isIgnored) {
           log.warn("Input path is gitignored: ${pathFile.path}")
-          val input = pathResolver.toDependentTaskOutputs(pathFile, project.basedir)
-          dependentTaskOutputInputs.add(input)
+          // For default inputs, always use **/* pattern
+          dependentTaskOutputInputs.add(DependentTaskOutputs("**/*", transitive = true))
         } else {
           val input = pathResolver.formatInputPath(pathFile, projectRoot = project.basedir)
 

packages/maven/src/executors/maven/maven-batch.impl.ts

@@ -197,7 +197,12 @@ export default async function* mavenBatchExecutor(
           console.error(output);
         }
       }
-      resolve();
+      // Reject promise if batch runner exited with non-zero code
+      if (code !== 0) {
+        reject(new Error(`Maven batch runner exited with code ${code}`));
+      } else {
+        resolve();
+      }
     });
     child.on('error', reject);
   });

packages/nx/src/tasks-runner/life-cycles/task-history-life-cycle-old.ts

@@ -13,14 +13,9 @@ import { LifeCycle, TaskResult } from '../life-cycle';
 
 export class LegacyTaskHistoryLifeCycle implements LifeCycle {
   private startTimings: Record<string, number> = {};
-  private taskRuns: TaskRun[] = [];
+  private pendingResults: TaskResult[] = [];
   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();
@@ -29,11 +24,19 @@ export class LegacyTaskHistoryLifeCycle implements LifeCycle {
 
   async endTasks(taskResults: TaskResult[]) {
     for (const taskResult of taskResults) {
-      // Track cacheable tasks for flaky detection
+      this.pendingResults.push(taskResult);
+    }
+  }
+
+  async endCommand() {
+    // Build TaskRun objects now — task.hash is guaranteed to be set by this point
+    const taskRuns: TaskRun[] = [];
+    const cacheableHashes = new Set<string>();
+    for (const taskResult of this.pendingResults) {
       if (taskResult.task.cache === true) {
-        this.cacheableHashes.add(taskResult.task.hash);
+        cacheableHashes.add(taskResult.task.hash);
       }
-      this.taskRuns.push({
+      taskRuns.push({
         project: taskResult.task.target.project,
         target: taskResult.task.target.target,
         configuration: taskResult.task.target.configuration,
@@ -46,13 +49,11 @@ export class LegacyTaskHistoryLifeCycle implements LifeCycle {
         end: (taskResult.task.endTime ?? new Date().getTime()).toString(),
       });
     }
-  }
 
-  async endCommand() {
-    await writeTaskRunsToHistory(this.taskRuns);
+    await writeTaskRunsToHistory(taskRuns);
     // Only check for flaky tasks among cacheable tasks
-    const cacheableTaskRuns = this.taskRuns.filter((t) =>
-      this.cacheableHashes.has(t.hash)
+    const cacheableTaskRuns = taskRuns.filter((t) =>
+      cacheableHashes.has(t.hash)
     );
     const history = await getHistoryForHashes(
       cacheableTaskRuns.map((t) => t.hash)

packages/nx/src/tasks-runner/life-cycles/task-history-life-cycle.ts

@@ -30,6 +30,7 @@ export function getTasksHistoryLifeCycle():
 
 export class TaskHistoryLifeCycle implements LifeCycle {
   private startTimings: Record<string, number> = {};
+  private pendingResults = new Map<string, TaskResult>();
   private taskRuns = new Map<string, TaskRun>();
   private taskHistory: TaskHistory | null = getTaskHistory();
   private flakyTasks: string[];
@@ -51,6 +52,17 @@ export class TaskHistoryLifeCycle implements LifeCycle {
 
   async endTasks(taskResults: TaskResult[]) {
     for (const taskResult of taskResults) {
+      this.pendingResults.set(taskResult.task.id, taskResult);
+    }
+  }
+
+  async endCommand() {
+    if (!this.taskHistory) {
+      return;
+    }
+
+    // Build TaskRun objects now — task.hash is guaranteed to be set by this point
+    for (const [, taskResult] of this.pendingResults) {
       this.taskRuns.set(taskResult.task.hash, {
         hash: taskResult.task.hash,
         target: taskResult.task.target,
@@ -62,12 +74,7 @@ export class TaskHistoryLifeCycle implements LifeCycle {
         cacheable: taskResult.task.cache === true,
       });
     }
-  }
 
-  async endCommand() {
-    if (!this.taskHistory) {
-      return;
-    }
     const runs = [];
 
     // Only check for flaky tasks among cacheable tasks