nx 21.0.0-canary.20250419-8619c1d → 21.0.0-canary.20250423-16fc551

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nx",
-  "version": "21.0.0-canary.20250419-8619c1d",
+  "version": "21.0.0-canary.20250423-16fc551",
   "private": false,
   "description": "The core Nx plugin contains the core functionality of Nx like the project graph, nx commands and task orchestration.",
   "repository": {
@@ -83,16 +83,16 @@
     }
   },
   "optionalDependencies": {
-    "@nx/nx-darwin-arm64": "21.0.0-canary.20250419-8619c1d",
-    "@nx/nx-darwin-x64": "21.0.0-canary.20250419-8619c1d",
-    "@nx/nx-freebsd-x64": "21.0.0-canary.20250419-8619c1d",
-    "@nx/nx-linux-arm-gnueabihf": "21.0.0-canary.20250419-8619c1d",
-    "@nx/nx-linux-arm64-gnu": "21.0.0-canary.20250419-8619c1d",
-    "@nx/nx-linux-arm64-musl": "21.0.0-canary.20250419-8619c1d",
-    "@nx/nx-linux-x64-gnu": "21.0.0-canary.20250419-8619c1d",
-    "@nx/nx-linux-x64-musl": "21.0.0-canary.20250419-8619c1d",
-    "@nx/nx-win32-arm64-msvc": "21.0.0-canary.20250419-8619c1d",
-    "@nx/nx-win32-x64-msvc": "21.0.0-canary.20250419-8619c1d"
+    "@nx/nx-darwin-arm64": "21.0.0-canary.20250423-16fc551",
+    "@nx/nx-darwin-x64": "21.0.0-canary.20250423-16fc551",
+    "@nx/nx-freebsd-x64": "21.0.0-canary.20250423-16fc551",
+    "@nx/nx-linux-arm-gnueabihf": "21.0.0-canary.20250423-16fc551",
+    "@nx/nx-linux-arm64-gnu": "21.0.0-canary.20250423-16fc551",
+    "@nx/nx-linux-arm64-musl": "21.0.0-canary.20250423-16fc551",
+    "@nx/nx-linux-x64-gnu": "21.0.0-canary.20250423-16fc551",
+    "@nx/nx-linux-x64-musl": "21.0.0-canary.20250423-16fc551",
+    "@nx/nx-win32-arm64-msvc": "21.0.0-canary.20250423-16fc551",
+    "@nx/nx-win32-x64-msvc": "21.0.0-canary.20250423-16fc551"
   },
   "nx-migrations": {
     "migrations": "./migrations.json",

package/src/native/index.d.ts

@@ -322,7 +322,8 @@ export declare const enum TaskStatus {
   RemoteCache = 5,
   NotStarted = 6,
   InProgress = 7,
-  Shared = 8
+  Shared = 8,
+  Stopped = 9
 }
 
 export interface TaskTarget {

package/src/tasks-runner/default-tasks-runner.js

@@ -65,7 +65,7 @@ const defaultTasksRunner = async (tasks, options, context) => {
 };
 exports.defaultTasksRunner = defaultTasksRunner;
 async function runAllTasks(options, context) {
-    const orchestrator = new task_orchestrator_1.TaskOrchestrator(context.hasher, context.initiatingProject, context.projectGraph, context.taskGraph, context.nxJson, options, context.nxArgs?.nxBail, context.daemon, context.nxArgs?.outputStyle);
+    const orchestrator = new task_orchestrator_1.TaskOrchestrator(context.hasher, context.initiatingProject, context.initiatingTasks, context.projectGraph, context.taskGraph, context.nxJson, options, context.nxArgs?.nxBail, context.daemon, context.nxArgs?.outputStyle);
     return orchestrator.run();
 }
 exports.default = exports.defaultTasksRunner;

package/src/tasks-runner/forked-process-task-runner.js

@@ -140,6 +140,9 @@ class ForkedProcessTaskRunner {
             }
             this.pseudoTerminals.delete(pseudoTerminal);
             this.processes.delete(p);
+            if (!streamOutput) {
+                this.options.lifeCycle.printTaskTerminalOutput(task, code === 0 ? 'success' : 'failure', terminalOutput);
+            }
             this.writeTerminalOutput(temporaryOutputPath, terminalOutput);
         });
         return p;

package/src/tasks-runner/init-tasks-runner.js

@@ -61,6 +61,7 @@ async function initTasksRunner(nxArgs) {
                 nxArgs: { ...nxArgs, parallel: opts.parallel },
                 loadDotEnvFiles: true,
                 initiatingProject: null,
+                initiatingTasks: [],
             });
             return {
                 status: Object.values(taskResults).some((taskResult) => taskResult.status === 'failure' || taskResult.status === 'skipped')
@@ -98,7 +99,7 @@ async function createOrchestrator(tasks, projectGraph, taskGraphForHashing, nxJs
             return acc;
         }, {}),
     };
-    const orchestrator = new task_orchestrator_1.TaskOrchestrator(hasher, null, projectGraph, taskGraph, nxJson, { ...options, parallel: tasks.length, lifeCycle: compositedLifeCycle }, false, client_1.daemonClient, undefined, taskGraphForHashing);
+    const orchestrator = new task_orchestrator_1.TaskOrchestrator(hasher, null, [], projectGraph, taskGraph, nxJson, { ...options, parallel: tasks.length, lifeCycle: compositedLifeCycle }, false, client_1.daemonClient, undefined, taskGraphForHashing);
     await orchestrator.init();
     await Promise.all(tasks.map((task) => orchestrator.processTask(task.id)));
     return orchestrator;

package/src/tasks-runner/life-cycle.d.ts

@@ -36,7 +36,7 @@ export interface LifeCycle {
     startTasks?(task: Task[], metadata: TaskMetadata): void | Promise<void>;
     endTasks?(taskResults: TaskResult[], metadata: TaskMetadata): void | Promise<void>;
     printTaskTerminalOutput?(task: Task, status: TaskStatus, output: string): void;
-    registerRunningTask?(taskId: string, parserAndWriter: ExternalObject<[any, any]>): Promise<void>;
+    registerRunningTask?(taskId: string, parserAndWriter: ExternalObject<[any, any]>): void;
     setTaskStatus?(taskId: string, status: NativeTaskStatus): void;
     registerForcedShutdownCallback?(callback: () => void): void;
 }
@@ -51,7 +51,7 @@ export declare class CompositeLifeCycle implements LifeCycle {
     startTasks(tasks: Task[], metadata: TaskMetadata): Promise<void>;
     endTasks(taskResults: TaskResult[], metadata: TaskMetadata): Promise<void>;
     printTaskTerminalOutput(task: Task, status: TaskStatus, output: string): void;
-    registerRunningTask(taskId: string, parserAndWriter: ExternalObject<[any, any]>): Promise<void>;
+    registerRunningTask(taskId: string, parserAndWriter: ExternalObject<[any, any]>): void;
     setTaskStatus(taskId: string, status: NativeTaskStatus): void;
     registerForcedShutdownCallback(callback: () => void): void;
 }

package/src/tasks-runner/life-cycle.js

@@ -67,10 +67,10 @@ class CompositeLifeCycle {
             }
         }
     }
-    async registerRunningTask(taskId, parserAndWriter) {
+    registerRunningTask(taskId, parserAndWriter) {
         for (let l of this.lifeCycles) {
             if (l.registerRunningTask) {
-                await l.registerRunningTask(taskId, parserAndWriter);
+                l.registerRunningTask(taskId, parserAndWriter);
             }
         }
     }

package/src/tasks-runner/life-cycles/tui-summary-life-cycle.d.ts

@@ -1,6 +1,6 @@
 import { Task } from '../../config/task-graph';
 import type { LifeCycle } from '../life-cycle';
-export declare function getTuiTerminalSummaryLifeCycle({ projectNames, tasks, args, overrides, initiatingProject, resolveRenderIsDonePromise, }: {
+export declare function getTuiTerminalSummaryLifeCycle({ projectNames, tasks, args, overrides, initiatingProject, initiatingTasks, resolveRenderIsDonePromise, }: {
     projectNames: string[];
     tasks: Task[];
     args: {
@@ -10,6 +10,7 @@ export declare function getTuiTerminalSummaryLifeCycle({ projectNames, tasks, ar
     };
     overrides: Record<string, unknown>;
     initiatingProject: string;
+    initiatingTasks: Task[];
     resolveRenderIsDonePromise: (value: void) => void;
 }): {
     lifeCycle: Partial<LifeCycle>;

package/src/tasks-runner/life-cycles/tui-summary-life-cycle.js

@@ -10,7 +10,7 @@ const figures = require("figures");
 const LEFT_PAD = `   `;
 const SPACER = `  `;
 const EXTENDED_LEFT_PAD = `      `;
-function getTuiTerminalSummaryLifeCycle({ projectNames, tasks, args, overrides, initiatingProject, resolveRenderIsDonePromise, }) {
+function getTuiTerminalSummaryLifeCycle({ projectNames, tasks, args, overrides, initiatingProject, initiatingTasks, resolveRenderIsDonePromise, }) {
     const lifeCycle = {};
     const start = process.hrtime();
     const targets = args.targets;
@@ -19,6 +19,7 @@ function getTuiTerminalSummaryLifeCycle({ projectNames, tasks, args, overrides,
     let totalSuccessfulTasks = 0;
     let totalFailedTasks = 0;
     let totalCompletedTasks = 0;
+    let totalStoppedTasks = 0;
     let timeTakenText;
     const failedTasks = new Set();
     const inProgressTasks = new Set();
@@ -30,14 +31,19 @@ function getTuiTerminalSummaryLifeCycle({ projectNames, tasks, args, overrides,
         }
     };
     lifeCycle.printTaskTerminalOutput = (task, taskStatus, terminalOutput) => {
-        tasksToTerminalOutputs[task.id] = { terminalOutput, taskStatus };
         taskIdsInOrderOfCompletion.push(task.id);
+        tasksToTerminalOutputs[task.id] = { terminalOutput, taskStatus };
+    };
+    lifeCycle.setTaskStatus = (taskId, taskStatus) => {
+        if (taskStatus === 9 /* NativeTaskStatus.Stopped */) {
+            totalStoppedTasks++;
+        }
     };
     lifeCycle.endTasks = (taskResults) => {
-        for (let t of taskResults) {
+        for (const { task, status } of taskResults) {
             totalCompletedTasks++;
-            inProgressTasks.delete(t.task.id);
-            switch (t.status) {
+            inProgressTasks.delete(task.id);
+            switch (status) {
                 case 'remote-cache':
                 case 'local-cache':
                 case 'local-cache-kept-existing':
@@ -49,7 +55,7 @@ function getTuiTerminalSummaryLifeCycle({ projectNames, tasks, args, overrides,
                     break;
                 case 'failure':
                     totalFailedTasks++;
-                    failedTasks.add(t.task.id);
+                    failedTasks.add(task.id);
                     break;
             }
         }
@@ -75,7 +81,7 @@ function getTuiTerminalSummaryLifeCycle({ projectNames, tasks, args, overrides,
     };
     const printRunOneSummary = () => {
         let lines = [];
-        const failure = totalSuccessfulTasks !== totalTasks;
+        const failure = totalSuccessfulTasks + totalStoppedTasks !== totalTasks;
         // Prints task outputs in the order they were completed
         // above the summary, since run-one should print all task results.
         for (const taskId of taskIdsInOrderOfCompletion) {
@@ -99,7 +105,7 @@ function getTuiTerminalSummaryLifeCycle({ projectNames, tasks, args, overrides,
             }
             lines = [output_1.output.colors.green(lines.join(node_os_1.EOL))];
         }
-        else if (totalCompletedTasks === totalTasks) {
+        else if (totalCompletedTasks + totalStoppedTasks === totalTasks) {
             let text = `Ran target ${output_1.output.bold(targets[0])} for project ${output_1.output.bold(initiatingProject)}`;
             if (tasks.length > 1) {
                 text += ` and ${output_1.output.bold(tasks.length - 1)} task(s) they depend on`;
@@ -137,7 +143,7 @@ function getTuiTerminalSummaryLifeCycle({ projectNames, tasks, args, overrides,
     const printRunManySummary = () => {
         console.log('');
         const lines = [];
-        const failure = totalSuccessfulTasks !== totalTasks;
+        const failure = totalSuccessfulTasks + totalStoppedTasks !== totalTasks;
         for (const taskId of taskIdsInOrderOfCompletion) {
             const { terminalOutput, taskStatus } = tasksToTerminalOutputs[taskId];
             if (taskStatus === 'failure') {
@@ -149,7 +155,7 @@ function getTuiTerminalSummaryLifeCycle({ projectNames, tasks, args, overrides,
             }
         }
         lines.push(...output_1.output.getVerticalSeparatorLines(failure ? 'red' : 'green'));
-        if (totalSuccessfulTasks === totalTasks) {
+        if (totalSuccessfulTasks + totalStoppedTasks === totalTasks) {
             const successSummaryRows = [];
             const text = `Successfully ran ${(0, formatting_utils_1.formatTargetsAndProjects)(projectNames, targets, tasks)}`;
             const taskOverridesRows = [];

package/src/tasks-runner/run-command.d.ts

@@ -17,7 +17,7 @@ export declare function runCommandForTasks(projectsToRun: ProjectGraphProjectNod
     excludeTaskDependencies: boolean;
     loadDotEnvFiles: boolean;
 }): Promise<TaskResults>;
-export declare function invokeTasksRunner({ tasks, projectGraph, taskGraph, lifeCycle, nxJson, nxArgs, loadDotEnvFiles, initiatingProject, }: {
+export declare function invokeTasksRunner({ tasks, projectGraph, taskGraph, lifeCycle, nxJson, nxArgs, loadDotEnvFiles, initiatingProject, initiatingTasks, }: {
     tasks: Task[];
     projectGraph: ProjectGraph;
     taskGraph: TaskGraph;
@@ -26,6 +26,7 @@ export declare function invokeTasksRunner({ tasks, projectGraph, taskGraph, life
     nxArgs: NxArgs;
     loadDotEnvFiles: boolean;
     initiatingProject: string | null;
+    initiatingTasks: Task[];
 }): Promise<{
     [id: string]: TaskResult;
 }>;

package/src/tasks-runner/run-command.js

@@ -46,7 +46,7 @@ const originalStdoutWrite = process.stdout.write.bind(process.stdout);
 const originalStderrWrite = process.stderr.write.bind(process.stderr);
 const originalConsoleLog = console.log.bind(console);
 const originalConsoleError = console.error.bind(console);
-async function getTerminalOutputLifeCycle(initiatingProject, projectNames, tasks, taskGraph, nxArgs, nxJson, overrides) {
+async function getTerminalOutputLifeCycle(initiatingProject, initiatingTasks, projectNames, tasks, taskGraph, nxArgs, nxJson, overrides) {
     const overridesWithoutHidden = { ...overrides };
     delete overridesWithoutHidden['__overrides_unparsed__'];
     if ((0, is_tui_enabled_1.isTuiEnabled)(nxJson)) {
@@ -82,7 +82,7 @@ async function getTerminalOutputLifeCycle(initiatingProject, projectNames, tasks
         const projectText = projectNames.length === 1 ? 'project' : 'projects';
         let titleText = '';
         if (isRunOne) {
-            const mainTaskId = (0, create_task_graph_1.createTaskId)(initiatingProject, nxArgs.targets[0], nxArgs.configuration);
+            const mainTaskId = initiatingTasks[0].id;
             pinnedTasks.push(mainTaskId);
             const mainContinuousDependencies = taskGraph.continuousDependencies[mainTaskId];
             if (mainContinuousDependencies.length > 0) {
@@ -111,6 +111,7 @@ async function getTerminalOutputLifeCycle(initiatingProject, projectNames, tasks
             args: nxArgs,
             overrides: overridesWithoutHidden,
             initiatingProject,
+            initiatingTasks,
             resolveRenderIsDonePromise,
         });
         if (tasks.length === 0) {
@@ -120,7 +121,6 @@ async function getTerminalOutputLifeCycle(initiatingProject, projectNames, tasks
                 process.stderr.write = originalStderrWrite;
                 console.log = originalConsoleLog;
                 console.error = originalConsoleError;
-                printSummary();
             });
         }
         const lifeCycles = [tsLifeCycle];
@@ -183,7 +183,6 @@ async function getTerminalOutputLifeCycle(initiatingProject, projectNames, tasks
                 process.stderr.write = originalStderrWrite;
                 console.log = originalConsoleLog;
                 console.error = originalConsoleError;
-                printSummary();
                 // Print the intercepted Nx Cloud logs
                 for (const log of interceptedNxCloudLogs) {
                     const logString = log.toString().trimStart();
@@ -196,6 +195,7 @@ async function getTerminalOutputLifeCycle(initiatingProject, projectNames, tasks
         }
         return {
             lifeCycle: new life_cycle_1.CompositeLifeCycle(lifeCycles),
+            printSummary,
             renderIsDone,
         };
     }
@@ -285,9 +285,12 @@ async function runCommand(projectsToRun, currentProjectGraph, { nxJson }, nxArgs
 }
 async function runCommandForTasks(projectsToRun, currentProjectGraph, { nxJson }, nxArgs, overrides, initiatingProject, extraTargetDependencies, extraOptions) {
     const projectNames = projectsToRun.map((t) => t.name);
+    const projectNameSet = new Set(projectNames);
     const { projectGraph, taskGraph } = await ensureWorkspaceIsInSyncAndGetGraphs(currentProjectGraph, nxJson, projectNames, nxArgs, overrides, extraTargetDependencies, extraOptions);
     const tasks = Object.values(taskGraph.tasks);
-    const { lifeCycle, renderIsDone } = await getTerminalOutputLifeCycle(initiatingProject, projectNames, tasks, taskGraph, nxArgs, nxJson, overrides);
+    const initiatingTasks = tasks.filter((t) => projectNameSet.has(t.target.project) &&
+        nxArgs.targets.includes(t.target.target));
+    const { lifeCycle, renderIsDone, printSummary } = await getTerminalOutputLifeCycle(initiatingProject, initiatingTasks, projectNames, tasks, taskGraph, nxArgs, nxJson, overrides);
     const taskResults = await invokeTasksRunner({
         tasks,
         projectGraph,
@@ -297,8 +300,12 @@ async function runCommandForTasks(projectsToRun, currentProjectGraph, { nxJson }
         nxArgs,
         loadDotEnvFiles: extraOptions.loadDotEnvFiles,
         initiatingProject,
+        initiatingTasks,
     });
     await renderIsDone;
+    if (printSummary) {
+        printSummary();
+    }
     await (0, nx_key_1.printNxKey)();
     return taskResults;
 }
@@ -535,7 +542,7 @@ function setEnvVarsBasedOnArgs(nxArgs, loadDotEnvFiles) {
         process.env.NX_LOAD_DOT_ENV_FILES = 'true';
     }
 }
-async function invokeTasksRunner({ tasks, projectGraph, taskGraph, lifeCycle, nxJson, nxArgs, loadDotEnvFiles, initiatingProject, }) {
+async function invokeTasksRunner({ tasks, projectGraph, taskGraph, lifeCycle, nxJson, nxArgs, loadDotEnvFiles, initiatingProject, initiatingTasks, }) {
     setEnvVarsBasedOnArgs(nxArgs, loadDotEnvFiles);
     // this needs to be done before we start to run the tasks
     const taskDetails = (0, hash_task_1.getTaskDetails)();
@@ -555,6 +562,7 @@ async function invokeTasksRunner({ tasks, projectGraph, taskGraph, lifeCycle, nx
         lifeCycle: compositedLifeCycle,
     }, {
         initiatingProject: nxArgs.outputStyle === 'compact' ? null : initiatingProject,
+        initiatingTasks,
         projectGraph,
         nxJson,
         nxArgs,

package/src/tasks-runner/running-tasks/node-child-process.js

@@ -153,18 +153,11 @@ class NodeChildProcessWithDirectOutput {
         this.exitCallbacks.push(cb);
     }
     async getResults() {
-        const terminalOutput = this.getTerminalOutput();
-        if (this.exited) {
-            return Promise.resolve({
-                code: this.exitCode,
-                terminalOutput,
-            });
+        if (!this.exited) {
+            await this.waitForExit();
         }
-        await this.waitForExit();
-        return Promise.resolve({
-            code: this.exitCode,
-            terminalOutput,
-        });
+        const terminalOutput = this.getTerminalOutput();
+        return { code: this.exitCode, terminalOutput };
     }
     waitForExit() {
         return new Promise((res) => {

package/src/tasks-runner/running-tasks/running-task.d.ts

@@ -1,3 +1,4 @@
+import type { Serializable } from 'child_process';
 export declare abstract class RunningTask {
     abstract getResults(): Promise<{
         code: number;
@@ -5,4 +6,5 @@ export declare abstract class RunningTask {
     }>;
     abstract onExit(cb: (code: number) => void): void;
     abstract kill(signal?: NodeJS.Signals | number): Promise<void> | void;
+    abstract send?(message: Serializable): void;
 }

package/src/tasks-runner/running-tasks/shared-running-task.d.ts

@@ -0,0 +1,14 @@
+import { RunningTask } from './running-task';
+import { RunningTasksService } from '../../native';
+export declare class SharedRunningTask implements RunningTask {
+    private runningTasksService;
+    private exitCallbacks;
+    constructor(runningTasksService: RunningTasksService, taskId: string);
+    getResults(): Promise<{
+        code: number;
+        terminalOutput: string;
+    }>;
+    kill(): void;
+    onExit(cb: (code: number) => void): void;
+    private waitForTaskToFinish;
+}

package/src/tasks-runner/running-tasks/shared-running-task.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SharedRunningTask = void 0;
+class SharedRunningTask {
+    constructor(runningTasksService, taskId) {
+        this.runningTasksService = runningTasksService;
+        this.exitCallbacks = [];
+        this.waitForTaskToFinish(taskId).then(() => {
+            // notify exit callbacks
+            this.exitCallbacks.forEach((cb) => cb(0));
+        });
+    }
+    async getResults() {
+        throw new Error('Results cannot be retrieved from a shared task');
+    }
+    kill() {
+        this.exitCallbacks.forEach((cb) => cb(0));
+    }
+    onExit(cb) {
+        this.exitCallbacks.push(cb);
+    }
+    async waitForTaskToFinish(taskId) {
+        console.log(`Waiting for ${taskId} in another nx process`);
+        // wait for the running task to finish
+        do {
+            await new Promise((resolve) => setTimeout(resolve, 100));
+        } while (this.runningTasksService.getRunningTasks([taskId]).length);
+    }
+}
+exports.SharedRunningTask = SharedRunningTask;

package/src/tasks-runner/task-orchestrator.d.ts

@@ -7,9 +7,11 @@ import { NxArgs } from '../utils/command-line-utils';
 import { DefaultTasksRunnerOptions } from './default-tasks-runner';
 import { RunningTask } from './running-tasks/running-task';
 import { TaskStatus } from './tasks-runner';
+import { SharedRunningTask } from './running-tasks/shared-running-task';
 export declare class TaskOrchestrator {
     private readonly hasher;
     private readonly initiatingProject;
+    private readonly initiatingTasks;
     private readonly projectGraph;
     private readonly taskGraph;
     private readonly nxJson;
@@ -26,6 +28,7 @@ export declare class TaskOrchestrator {
     private tasksSchedule;
     private batchEnv;
     private reverseTaskDeps;
+    private initializingTaskIds;
     private processedTasks;
     private processedBatches;
     private completedTasks;
@@ -33,8 +36,7 @@ export declare class TaskOrchestrator {
     private groups;
     private bailed;
     private runningContinuousTasks;
-    private cleaningUp;
-    constructor(hasher: TaskHasher, initiatingProject: string | undefined, projectGraph: ProjectGraph, taskGraph: TaskGraph, nxJson: NxJsonConfiguration, options: NxArgs & DefaultTasksRunnerOptions, bail: boolean, daemon: DaemonClient, outputStyle: string, taskGraphForHashing?: TaskGraph);
+    constructor(hasher: TaskHasher, initiatingProject: string | undefined, initiatingTasks: Task[], projectGraph: ProjectGraph, taskGraph: TaskGraph, nxJson: NxJsonConfiguration, options: NxArgs & DefaultTasksRunnerOptions, bail: boolean, daemon: DaemonClient, outputStyle: string, taskGraphForHashing?: TaskGraph);
     init(): Promise<void>;
     run(): Promise<{
         [id: string]: TaskStatus;
@@ -55,7 +57,7 @@ export declare class TaskOrchestrator {
     }>;
     private runTask;
     private runTaskInForkedProcess;
-    startContinuousTask(task: Task, groupId: number): Promise<RunningTask>;
+    startContinuousTask(task: Task, groupId: number): Promise<RunningTask | SharedRunningTask>;
     private preRunSteps;
     private postRunSteps;
     private scheduleNextTasksAndReleaseThreads;
@@ -67,5 +69,6 @@ export declare class TaskOrchestrator {
     private shouldCopyOutputsFromCache;
     private recordOutputsHash;
     private cleanup;
+    private cleanUpUnneededContinuousTasks;
 }
 export declare function getThreadCount(options: NxArgs & DefaultTasksRunnerOptions, taskGraph: TaskGraph): number;

package/src/tasks-runner/task-orchestrator.js

@@ -21,11 +21,13 @@ const noop_child_process_1 = require("./running-tasks/noop-child-process");
 const task_env_1 = require("./task-env");
 const tasks_schedule_1 = require("./tasks-schedule");
 const utils_1 = require("./utils");
+const shared_running_task_1 = require("./running-tasks/shared-running-task");
 class TaskOrchestrator {
     // endregion internal state
-    constructor(hasher, initiatingProject, projectGraph, taskGraph, nxJson, options, bail, daemon, outputStyle, taskGraphForHashing = taskGraph) {
+    constructor(hasher, initiatingProject, initiatingTasks, projectGraph, taskGraph, nxJson, options, bail, daemon, outputStyle, taskGraphForHashing = taskGraph) {
         this.hasher = hasher;
         this.initiatingProject = initiatingProject;
+        this.initiatingTasks = initiatingTasks;
         this.projectGraph = projectGraph;
         this.taskGraph = taskGraph;
         this.nxJson = nxJson;
@@ -43,6 +45,7 @@ class TaskOrchestrator {
         // region internal state
         this.batchEnv = (0, task_env_1.getEnvVariablesForBatchProcess)(this.options.skipNxCache, this.options.captureStderr);
         this.reverseTaskDeps = (0, utils_1.calculateReverseDeps)(this.taskGraph);
+        this.initializingTaskIds = new Set(this.initiatingTasks.map((t) => t.id));
         this.processedTasks = new Map();
         this.processedBatches = new Map();
         this.completedTasks = {};
@@ -50,7 +53,6 @@ class TaskOrchestrator {
         this.groups = [];
         this.bailed = false;
         this.runningContinuousTasks = new Map();
-        this.cleaningUp = false;
     }
     async init() {
         // Init the ForkedProcessTaskRunner, TasksSchedule, and Cache
@@ -397,15 +399,27 @@ class TaskOrchestrator {
             if (this.tuiEnabled) {
                 this.options.lifeCycle.setTaskStatus(task.id, 8 /* NativeTaskStatus.Shared */);
             }
+            const runningTask = new shared_running_task_1.SharedRunningTask(this.runningTasksService, task.id);
+            this.runningContinuousTasks.set(task.id, runningTask);
+            runningTask.onExit(() => {
+                this.runningContinuousTasks.delete(task.id);
+            });
             // task is already running by another process, we schedule the next tasks
             // and release the threads
             await this.scheduleNextTasksAndReleaseThreads();
-            // wait for the running task to finish
-            do {
-                console.log(`Waiting for ${task.id} in another nx process`);
-                await new Promise((resolve) => setTimeout(resolve, 100));
-            } while (this.runningTasksService.getRunningTasks([task.id]).length);
-            return;
+            if (this.initializingTaskIds.has(task.id)) {
+                await new Promise((res) => {
+                    runningTask.onExit((code) => {
+                        if (!this.tuiEnabled) {
+                            if (code > 128) {
+                                process.exit(code);
+                            }
+                        }
+                        res();
+                    });
+                });
+            }
+            return runningTask;
         }
         const taskSpecificEnv = await this.processedTasks.get(task.id);
         await this.preRunSteps([task], { groupId });
@@ -425,14 +439,20 @@ class TaskOrchestrator {
         this.runningContinuousTasks.set(task.id, childProcess);
         childProcess.onExit(() => {
             this.runningTasksService.removeRunningTask(task.id);
+            this.runningContinuousTasks.delete(task.id);
         });
-        if (this.initiatingProject === task.target.project &&
-            this.options.targets.length === 1 &&
-            this.options.targets[0] === task.target.target) {
-            await childProcess.getResults();
-        }
-        else {
-            await this.scheduleNextTasksAndReleaseThreads();
+        await this.scheduleNextTasksAndReleaseThreads();
+        if (this.initializingTaskIds.has(task.id)) {
+            await new Promise((res) => {
+                childProcess.onExit((code) => {
+                    if (!this.tuiEnabled) {
+                        if (code > 128) {
+                            process.exit(code);
+                        }
+                    }
+                    res();
+                });
+            });
         }
         return childProcess;
     }
@@ -505,6 +525,7 @@ class TaskOrchestrator {
     }
     complete(taskResults) {
         this.tasksSchedule.complete(taskResults.map(({ taskId }) => taskId));
+        this.cleanUpUnneededContinuousTasks();
         for (const { taskId, status } of taskResults) {
             if (this.completedTasks[taskId] === undefined) {
                 this.completedTasks[taskId] = status;
@@ -571,10 +592,10 @@ class TaskOrchestrator {
     }
     // endregion utils
     async cleanup() {
-        this.cleaningUp = true;
         await Promise.all(Array.from(this.runningContinuousTasks).map(async ([taskId, t]) => {
             try {
-                return t.kill();
+                await t.kill();
+                this.options.lifeCycle.setTaskStatus(taskId, 9 /* NativeTaskStatus.Stopped */);
             }
             catch (e) {
                 console.error(`Unable to terminate ${taskId}\nError:`, e);
@@ -584,6 +605,25 @@ class TaskOrchestrator {
             }
         }));
     }
+    cleanUpUnneededContinuousTasks() {
+        const incompleteTasks = this.tasksSchedule.getIncompleteTasks();
+        const neededContinuousTasks = new Set(this.initializingTaskIds);
+        for (const task of incompleteTasks) {
+            const continuousDependencies = this.taskGraph.continuousDependencies[task.id];
+            for (const continuousDependency of continuousDependencies) {
+                neededContinuousTasks.add(continuousDependency);
+            }
+        }
+        for (const taskId of this.runningContinuousTasks.keys()) {
+            if (!neededContinuousTasks.has(taskId)) {
+                const runningTask = this.runningContinuousTasks.get(taskId);
+                if (runningTask) {
+                    runningTask.kill();
+                    this.options.lifeCycle.setTaskStatus(taskId, 9 /* NativeTaskStatus.Stopped */);
+                }
+            }
+        }
+    }
 }
 exports.TaskOrchestrator = TaskOrchestrator;
 function getThreadCount(options, taskGraph) {

package/src/tasks-runner/tasks-runner.d.ts

@@ -12,6 +12,7 @@ export type TaskStatus = 'success' | 'failure' | 'skipped' | 'local-cache-kept-e
 export type TasksRunner<T = unknown> = (tasks: Task[], options: T, context?: {
     target?: string;
     initiatingProject?: string | null;
+    initiatingTasks: Task[];
     projectGraph: ProjectGraph;
     nxJson: NxJsonConfiguration;
     nxArgs: NxArgs;

package/src/tasks-runner/tasks-schedule.d.ts

@@ -31,6 +31,7 @@ export declare class TasksSchedule {
     };
     nextTask(): Task;
     nextBatch(): Batch;
+    getIncompleteTasks(): Task[];
     private scheduleTasks;
     private scheduleTask;
     private scheduleBatches;

package/src/tasks-runner/tasks-schedule.js

@@ -68,6 +68,15 @@ class TasksSchedule {
             ? this.scheduledBatches.shift()
             : null;
     }
+    getIncompleteTasks() {
+        const incompleteTasks = [];
+        for (const taskId in this.taskGraph.tasks) {
+            if (!this.completedTasks.has(taskId)) {
+                incompleteTasks.push(this.taskGraph.tasks[taskId]);
+            }
+        }
+        return incompleteTasks;
+    }
     async scheduleTasks() {
         if (this.options.batch || process.env.NX_BATCH_MODE === 'true') {
             await this.scheduleBatches();