Does grunt.task.run inside a Grunt multi-task execute after the current target or only after all targets complete?

Direct answer

When a Grunt multi-task target calls grunt.task.run, the enqueued task does not execute after that individual target. It is appended to the global run queue and executes only after the entire multi-task has completed across all of its targets.

How the queue works

Grunt invokes a multi-task once per target, but it does not flush the task queue between those invocations. A call to grunt.task.run('someTask') inside any target adds someTask to the end of the global queue. That queued task becomes eligible only when the current task invocation signals completion: either by returning synchronously or by calling the done callback obtained from this.async(). Because the multi-task itself is not considered finished until every target has run, the enqueued task waits for the full multi-task lifecycle.

Role of this.async()

The async contract controls when the enqueued task becomes eligible. If a target calls this.async() and delays done(), the global queue does not advance until done() fires. In a synchronous target, the queue advances as soon as the target function returns. In both cases, the boundary is the completion of the current task invocation, not the completion of a single target within a multi-task.

Version assumptions

This behavior is consistent across the Grunt 0.4.x and 0.5.x series. Releases prior to 0.4.0 used a different queue implementation, so if you are on an extremely legacy version, verify the behavior separately rather than assuming the same ordering.

Verify in your project

Create a minimal Gruntfile to confirm the ordering:

module.exports = function(grunt) {
  grunt.initConfig({});

  grunt.registerTask('logAfter', function() {
    grunt.log.writeln('logAfter executed');
  });

  grunt.registerMultiTask('demo', function() {
    grunt.log.writeln('target start: ' + this.target);
    grunt.task.run('logAfter');
    grunt.log.writeln('target end: ' + this.target);
  });

  grunt.registerTask('default', ['demo:a', 'demo:b']);
};

Run grunt. The logAfter output should appear only after both demo:a and demo:b have printed their start and end lines. To test the async path, replace the multi-task body with var done = this.async(); setTimeout(done, 100); and observe that logAfter still waits until the delayed done() resolves.

If you need per-target interleaving

Grunt provides no supported mechanism to interleave a queued task between targets of a single multi-task invocation. If your build requires work to run after each target, restructure the logic into separate tasks and invoke them explicitly, or implement a custom iterator that calls done() per target and manages its own queue.