nx 23.0.0-beta.1 → 23.0.0-pr.33655.cdc3e72

package/dist/bin/nx.js

@@ -109,10 +109,10 @@ async function main() {
             warnIfUsingOutdatedGlobalInstall(GLOBAL_NX_VERSION, LOCAL_NX_VERSION);
             if (localNx.includes('.nx')) {
                 const nxWrapperPath = localNx.replace(/\.nx.*/, '.nx/') + 'nxw.js';
-                await import(nxWrapperPath);
+                require(nxWrapperPath);
             }
             else {
-                await import(localNx);
+                require(localNx);
             }
         }
     }

package/dist/src/command-line/release/utils/shared.js

@@ -15,6 +15,7 @@ const semver_1 = require("semver");
 const utils_1 = require("../../../tasks-runner/utils");
 const output_1 = require("../../../utils/output");
 const git_1 = require("./git");
+const find_matching_projects_1 = require("../../../utils/find-matching-projects");
 exports.noDiffInChangelogMessage = pc.yellow(`NOTE: There was no diff detected for the changelog entry. Maybe you intended to pass alternative git references via --from and --to?`);
 function isPrerelease(version) {
     // prerelease returns an array of matching prerelease "components", or null if the version is not a prerelease
@@ -329,23 +330,32 @@ async function getCommitsRelevantToProjects(projectGraph, commits, projects, nxR
         // Try to get the graph associated with the commit shortHash
         // if not available, calculate it and store it in the cache
         let affectedGraph = await releaseGraph.resolveAffectedFilesPerCommitInProjectGraph(commit, projectGraph);
+        // Resolve commit scopes using Nx matcher
+        const scopePatterns = commit.scope
+            ? commit.scope.split(',').map((s) => s.trim())
+            : [];
+        let scopedProjects = null;
+        if (scopePatterns.length > 0) {
+            const matches = (0, find_matching_projects_1.findMatchingProjects)(scopePatterns, projectGraph.nodes);
+            // detect ambiguity
+            for (const pattern of scopePatterns) {
+                const perPatternMatches = (0, find_matching_projects_1.findMatchingProjects)([pattern], projectGraph.nodes);
+                if (perPatternMatches.length > 1) {
+                    throw new Error(`Ambiguous scope "${pattern}" in commit "${commit.message}". ` +
+                        `Matches: ${perPatternMatches.join(', ')}`);
+                }
+            }
+            scopedProjects = new Set(matches);
+        }
         for (const projectName of Object.keys(affectedGraph.nodes)) {
             if (projectSet.has(projectName)) {
                 if (!relevantCommits.has(projectName)) {
                     relevantCommits.set(projectName, []);
                 }
-                if (commit.scope === projectName ||
-                    commit.scope.split(',').includes(projectName) ||
-                    !commit.scope) {
-                    relevantCommits
-                        .get(projectName)
-                        ?.push({ commit, isProjectScopedCommit: true });
-                }
-                else {
-                    relevantCommits
-                        .get(projectName)
-                        ?.push({ commit, isProjectScopedCommit: false });
-                }
+                const isProjectScopedCommit = scopedProjects === null || scopedProjects.has(projectName);
+                relevantCommits
+                    .get(projectName)
+                    ?.push({ commit, isProjectScopedCommit });
             }
         }
     }

package/dist/src/executors/run-commands/running-tasks.js

@@ -7,7 +7,7 @@ const pc = tslib_1.__importStar(require("picocolors"));
 const child_process_1 = require("child_process");
 const npm_run_path_1 = require("npm-run-path");
 const path_1 = require("path");
-const tree_kill_1 = tslib_1.__importDefault(require("tree-kill"));
+const native_1 = require("../../native");
 const pseudo_terminal_1 = require("../../tasks-runner/pseudo-terminal");
 const task_env_1 = require("../../tasks-runner/task-env");
 const task_io_service_1 = require("../../tasks-runner/task-io-service");
@@ -40,14 +40,7 @@ class ParallelRunningTasks {
         }
     }
     async kill(signal) {
-        await Promise.all(this.childProcesses.map(async (p) => {
-            try {
-                return p.kill();
-            }
-            catch (e) {
-                console.error(`Unable to terminate "${p.command}"\nError:`, e);
-            }
-        }));
+        await Promise.allSettled(this.childProcesses.map((p) => p.kill(signal)));
     }
     async run() {
         if (this.readyWhenStatus.length) {
@@ -93,7 +86,7 @@ class ParallelRunningTasks {
                     hasFailure = true;
                     failureDetails = { childProcess, code, terminalOutput };
                     // Immediately terminate all other running processes
-                    await this.terminateRemainingProcesses(runningProcesses, childProcess);
+                    this.terminateRemainingProcesses(runningProcesses, childProcess);
                 }
                 runningProcesses.delete(childProcess);
             }));
@@ -116,25 +109,11 @@ class ParallelRunningTasks {
             }
         }
     }
-    async terminateRemainingProcesses(runningProcesses, failedProcess) {
-        const terminationPromises = [];
+    terminateRemainingProcesses(runningProcesses, failedProcess) {
         const processesToTerminate = [...runningProcesses].filter((p) => p !== failedProcess);
         for (const process of processesToTerminate) {
             runningProcesses.delete(process);
-            // Terminate the process
-            terminationPromises.push(process.kill('SIGTERM').catch((err) => {
-                // Log error but don't fail the entire operation
-                if (this.streamOutput) {
-                    console.error(`Failed to terminate process "${process.command}":`, err);
-                }
-            }));
-        }
-        // Wait for all terminations to complete with a timeout
-        if (terminationPromises.length > 0) {
-            await Promise.race([
-                Promise.all(terminationPromises),
-                new Promise((resolve) => setTimeout(resolve, 5_000)),
-            ]);
+            process.kill('SIGTERM').catch(() => { });
         }
     }
 }
@@ -182,7 +161,7 @@ class SeriallyRunningTasks {
         throw new Error('Not implemented');
     }
     kill(signal) {
-        return this.currentProcess.kill(signal);
+        return this.currentProcess?.kill(signal);
     }
     async run(options, context) {
         for (const c of options.commands) {
@@ -236,6 +215,7 @@ class RunningNodeProcess {
         this.terminalOutputChunks = [];
         this.exitCallbacks = [];
         this.outputCallbacks = [];
+        this.killPromise = null;
         env = processEnv(color, cwd, env, envFile);
         this.command = commandConfig.command;
         const header = pc.dim('> ') + commandConfig.command + '\r\n\r\n';
@@ -245,9 +225,14 @@ class RunningNodeProcess {
         }
         this.childProcess = (0, child_process_1.spawn)(commandConfig.command, [], {
             shell: true,
+            detached: process.platform !== 'win32',
             env,
             cwd,
             windowsHide: true,
+            stdio: ['inherit', 'pipe', 'pipe'],
+        });
+        this.closedPromise = new Promise((resolve) => {
+            this.childProcess.on('close', resolve);
         });
         this.childProcess.stdout?.setEncoding('utf8');
         this.childProcess.stderr?.setEncoding('utf8');
@@ -275,18 +260,21 @@ class RunningNodeProcess {
         this.childProcess.send(message);
     }
     kill(signal) {
-        return new Promise((res, rej) => {
-            (0, tree_kill_1.default)(this.childProcess.pid, signal, (err) => {
-                // On Windows, tree-kill (which uses taskkill) may fail when the process or its child process is already terminated.
-                // Ignore the errors, otherwise we will log them unnecessarily.
-                if (err && process.platform !== 'win32') {
-                    rej(err);
-                }
-                else {
-                    res();
-                }
-            });
-        });
+        if (this.killPromise)
+            return this.killPromise;
+        if (!this.childProcess.pid)
+            return Promise.resolve();
+        // Cache the promise so concurrent callers (e.g. cleanup() after a
+        // fire-and-forget kill from cleanUpUnneededContinuousTasks) await the
+        // same in-progress operation instead of no-oping.
+        this.killPromise = (0, native_1.killProcessTreeGraceful)(this.childProcess.pid, signal).then(() => 
+        // Wait for stdio drain and close events before the orchestrator
+        // tears down the event loop via process.exit().
+        Promise.race([
+            this.closedPromise,
+            new Promise((resolve) => setTimeout(resolve, 1000)),
+        ]));
+        return this.killPromise;
     }
     triggerOutputListeners(output) {
         for (const cb of this.outputCallbacks) {
@@ -294,6 +282,34 @@ class RunningNodeProcess {
         }
     }
     addListeners(commandConfig, streamOutput) {
+        // Named handlers so they can be removed when the child exits.
+        // Otherwise each RunningNodeProcess leaks process listeners; with
+        // many run-commands tasks this triggers MaxListenersExceededWarning.
+        const isForked = !!process.env.NX_FORKED_TASK_EXECUTOR;
+        const onProcessExit = () => {
+            if (this.childProcess.pid && !this.killPromise) {
+                (0, native_1.killProcessTree)(this.childProcess.pid);
+            }
+        };
+        const onSigInt = () => {
+            this.kill('SIGTERM');
+        };
+        const onSigTerm = () => {
+            this.kill('SIGTERM');
+        };
+        const onSigHup = () => {
+            this.kill('SIGTERM');
+        };
+        const removeProcessListeners = () => {
+            process.removeListener('exit', onProcessExit);
+            if (isForked) {
+                process.removeListener('SIGINT', onSigInt);
+                process.removeListener('SIGTERM', onSigTerm);
+                process.removeListener('SIGHUP', onSigHup);
+            }
+        };
+        this.childProcess.stdout.setEncoding('utf8');
+        this.childProcess.stderr.setEncoding('utf8');
         this.childProcess.stdout.on('data', (data) => {
             const output = addColorAndPrefix(data, commandConfig);
             this.terminalOutputChunks.push(output);
@@ -301,8 +317,7 @@ class RunningNodeProcess {
             if (streamOutput) {
                 process.stdout.write(output);
             }
-            if (this.readyWhenStatus.length &&
-                isReady(this.readyWhenStatus, data.toString())) {
+            if (this.readyWhenStatus.length && isReady(this.readyWhenStatus, data)) {
                 for (const cb of this.exitCallbacks) {
                     cb(0, this.terminalOutputChunks.join(''));
                 }
@@ -315,8 +330,7 @@ class RunningNodeProcess {
             if (streamOutput) {
                 process.stderr.write(output);
             }
-            if (this.readyWhenStatus.length &&
-                isReady(this.readyWhenStatus, err.toString())) {
+            if (this.readyWhenStatus.length && isReady(this.readyWhenStatus, err)) {
                 for (const cb of this.exitCallbacks) {
                     cb(1, this.terminalOutputChunks.join(''));
                 }
@@ -335,29 +349,6 @@ class RunningNodeProcess {
                 cb(1, terminalOutput);
             }
         });
-        // Store signal/exit handlers so they can be removed when the child exits.
-        // Without cleanup, each RunningNodeProcess leaks 4 process listeners.
-        // In a large monorepo (2600+ run-commands tasks), these accumulate and
-        // cause a multi-minute synchronous hang at process.exit() as each handler
-        // calls treeKill on an already-dead PID.
-        const onExit = () => {
-            this.kill();
-        };
-        const onSigInt = () => {
-            this.kill('SIGTERM');
-        };
-        const onSigTerm = () => {
-            this.kill('SIGTERM');
-        };
-        const onSigHup = () => {
-            this.kill('SIGTERM');
-        };
-        const removeProcessListeners = () => {
-            process.removeListener('exit', onExit);
-            process.removeListener('SIGINT', onSigInt);
-            process.removeListener('SIGTERM', onSigTerm);
-            process.removeListener('SIGHUP', onSigHup);
-        };
         this.childProcess.on('exit', (code, signal) => {
             if (code === null) {
                 code = (0, exit_codes_1.signalToCode)(signal);
@@ -371,11 +362,19 @@ class RunningNodeProcess {
                 }
             }
         });
-        // Terminate any task processes on exit
-        process.on('exit', onExit);
-        process.on('SIGINT', onSigInt);
-        process.on('SIGTERM', onSigTerm);
-        process.on('SIGHUP', onSigHup);
+        // Terminate any task processes on exit (sync, last resort).
+        // Skip if graceful kill is already in progress — it tracks cleanup
+        // subprocesses and we must not interfere with them.
+        process.on('exit', onProcessExit);
+        // In the direct path, detached children don't get OS SIGINT (own process
+        // group via setsid); the orchestrator's cleanup() sends SIGTERM via
+        // killProcessTreeGraceful. Signal handlers here are only needed in the
+        // forked path where there's no orchestrator to dispatch signals.
+        if (isForked) {
+            process.on('SIGINT', onSigInt);
+            process.on('SIGTERM', onSigTerm);
+            process.on('SIGHUP', onSigHup);
+        }
     }
 }
 async function runSingleCommandWithPseudoTerminal(normalized, context, taskId) {
@@ -493,21 +492,31 @@ function registerProcessListener(runningTask, pseudoTerminal) {
             runningTask.send(message);
         }
     });
-    // Terminate any task processes on exit
+    // Terminate any task processes on exit (sync, last resort).
+    // The per-child exit handlers and PseudoTerminal.shutdown() use the
+    // sync killProcessTree for this path. We call kill() here as a
+    // best-effort fallback — it returns a Promise but on 'exit' only
+    // synchronous work runs, so the initial signal is sent but the
+    // grace period won't be awaited. That's acceptable: 'exit' is the
+    // last resort after SIGINT/SIGTERM handlers have already had their
+    // chance to do graceful shutdown.
     process.on('exit', () => {
         runningTask.kill();
     });
-    process.on('SIGINT', () => {
-        runningTask.kill('SIGTERM');
-    });
-    process.on('SIGTERM', () => {
-        runningTask.kill('SIGTERM');
-        // no exit here because we expect child processes to terminate which
-        // will store results to the cache and will terminate this process
-    });
-    process.on('SIGHUP', () => {
-        runningTask.kill('SIGTERM');
-        // no exit here because we expect child processes to terminate which
-        // will store results to the cache and will terminate this process
-    });
+    // In the direct path, the orchestrator handles signal dispatch to children.
+    // These handlers are only needed in the forked path where there's no
+    // orchestrator.
+    if (process.env.NX_FORKED_TASK_EXECUTOR) {
+        process.on('SIGINT', () => {
+            Promise.resolve(runningTask.kill('SIGTERM')).finally(() => {
+                process.exit((0, exit_codes_1.signalToCode)('SIGINT'));
+            });
+        });
+        process.on('SIGTERM', () => {
+            runningTask.kill('SIGTERM');
+        });
+        process.on('SIGHUP', () => {
+            runningTask.kill('SIGTERM');
+        });
+    }
 }

package/dist/src/executors/run-script/run-script.impl.js

@@ -4,7 +4,7 @@ exports.default = default_1;
 const tslib_1 = require("tslib");
 const child_process_1 = require("child_process");
 const path = tslib_1.__importStar(require("path"));
-const tree_kill_1 = tslib_1.__importDefault(require("tree-kill"));
+const native_1 = require("../../native");
 const pseudo_terminal_1 = require("../../tasks-runner/pseudo-terminal");
 const package_manager_1 = require("../../utils/package-manager");
 async function default_1(options, context) {
@@ -56,15 +56,8 @@ function nodeProcess(command, cwd, env) {
         });
         const exitHandler = (signal) => {
             if (cp && cp.pid && !cp.killed) {
-                (0, tree_kill_1.default)(cp.pid, signal, (error) => {
-                    // On Windows, tree-kill (which uses taskkill) may fail when the process or its child process is already terminated.
-                    // Ignore the errors, otherwise we will log them unnecessarily.
-                    if (error && process.platform !== 'win32') {
-                        rej(error);
-                    }
-                    else {
-                        res();
-                    }
+                (0, native_1.killProcessTreeGraceful)(cp.pid, signal).finally(() => {
+                    res();
                 });
             }
         };

package/dist/src/native/index.d.ts

@@ -52,7 +52,7 @@ export declare class AppLifeCycle {
 export declare class ChildProcess {
   getParserAndWriter(): ExternalObject<[ParserArc, WriterArc]>
   getPid(): number
-  kill(signal?: NodeJS.Signals): void
+  kill(signal?: NodeJS.Signals | number): void
   onExit(callback: (message: string) => void): void
   onOutput(callback: (message: string) => void): void
   cleanup(): void
@@ -465,6 +465,23 @@ export interface JsonInput {
   excludeFields?: Array<string>
 }
 
+/**
+ * Kill a process and all its descendants (fire-and-forget).
+ *
+ * Sends the requested signal but does NOT wait for processes to exit.
+ * Use `killProcessTreeGraceful` when cleanup handlers must run.
+ */
+export declare function killProcessTree(rootPid: number, signal?: string | number | undefined | null): void
+
+/**
+ * Kill a process tree gracefully: signal → wait → SIGKILL.
+ *
+ * Signals leaf processes first, waits for them to exit, then signals
+ * their parents (now leaves). Repeats until the tree is empty or the
+ * grace period expires, then force-kills survivors.
+ */
+export declare function killProcessTreeGraceful(rootPid: number, signal?: string | number | undefined | null, gracePeriodMs?: number | undefined | null): Promise<void>
+
 export declare function logDebug(message: string): void
 
 /** Combined metadata for groups and processes */

package/dist/src/native/native-bindings.js

@@ -620,6 +620,8 @@ module.exports.installNxConsoleForEditor = nativeBinding.installNxConsoleForEdit
 module.exports.IS_WASM = nativeBinding.IS_WASM
 module.exports.isAiAgent = nativeBinding.isAiAgent
 module.exports.isEditorInstalled = nativeBinding.isEditorInstalled
+module.exports.killProcessTree = nativeBinding.killProcessTree
+module.exports.killProcessTreeGraceful = nativeBinding.killProcessTreeGraceful
 module.exports.logDebug = nativeBinding.logDebug
 module.exports.parseTaskStatus = nativeBinding.parseTaskStatus
 module.exports.remove = nativeBinding.remove

package/dist/src/tasks-runner/forked-process-task-runner.d.ts

@@ -37,6 +37,6 @@ export declare class ForkedProcessTaskRunner {
     private forkProcessWithPrefixAndNotTTY;
     private forkProcessDirectOutputCapture;
     private writeTerminalOutput;
-    cleanup(signal?: NodeJS.Signals): void;
+    cleanup(signal?: NodeJS.Signals): Promise<void>;
     private setupProcessEventListeners;
 }

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

@@ -264,10 +264,8 @@ class ForkedProcessTaskRunner {
     writeTerminalOutput(outputPath, content) {
         (0, fs_1.writeFileSync)(outputPath, content);
     }
-    cleanup(signal) {
-        this.processes.forEach((p) => {
-            p.kill(signal);
-        });
+    async cleanup(signal) {
+        await Promise.all([...this.processes].map((p) => p.kill(signal)));
         this.cleanUpBatchProcesses();
     }
     setupProcessEventListeners() {
@@ -283,12 +281,27 @@ class ForkedProcessTaskRunner {
         };
         // When the nx process gets a message, it will be sent into the task's process
         process.on('message', messageHandler);
-        // Terminate any task processes on exit
+        // Terminate any task processes on exit (sync, last resort).
+        // cleanup() is async but the initial signal dispatch is synchronous
+        // (killProcessTreeGraceful snapshots and signals before the async
+        // grace period). The grace period won't complete here, but each
+        // child also has its own sync exit handler as a final fallback.
         process.once('exit', () => {
             this.cleanup();
             process.off('message', messageHandler);
         });
-        // Signal handlers removed - TaskOrchestrator owns signal handling
+        process.once('SIGINT', () => {
+            this.cleanup('SIGTERM').finally(() => {
+                process.off('message', messageHandler);
+                // No process.exit() here — the orchestrator's setupSignalHandlers()
+                // owns the exit decision for the direct path, and in the forked path
+                // the cleanup above is a no-op (0 processes).
+            });
+        });
+        // SIGTERM/SIGHUP are NOT handled here. The orchestrator's
+        // setupSignalHandlers() handles them and calls FPTR.cleanup()
+        // as part of its own cleanup sequence. Using process.once() here
+        // would consume the event before the orchestrator sees it.
     }
 }
 exports.ForkedProcessTaskRunner = ForkedProcessTaskRunner;

package/dist/src/tasks-runner/pseudo-terminal.d.ts

@@ -45,7 +45,7 @@ export declare class PseudoTtyProcess implements RunningTask {
     onExit(callback: (code: number, terminalOutput: string) => void): void;
     onOutput(callback: (message: string) => void): void;
     getPid(): number | undefined;
-    kill(s?: NodeJS.Signals): void;
+    kill(s?: NodeJS.Signals): Promise<void>;
     getParserAndWriter(): import("../native").ExternalObject<[import("../native").ParserArc, import("../native").WriterArc]>;
 }
 export declare class PseudoTtyProcessWithSend extends PseudoTtyProcess {

package/dist/src/tasks-runner/pseudo-terminal.js

@@ -41,9 +41,14 @@ class PseudoTerminal {
         this.initialized = true;
     }
     shutdown(code) {
+        // Called from process.on('exit') — must be synchronous/best-effort.
+        // Use fire-and-forget killProcessTree, not the async graceful variant.
         for (const cp of this.childProcesses) {
             try {
-                cp.kill((0, exit_codes_1.codeToSignal)(code));
+                const pid = cp.getPid();
+                if (pid) {
+                    (0, native_1.killProcessTree)(pid, (0, exit_codes_1.codeToSignal)(code));
+                }
             }
             catch { }
         }
@@ -110,17 +115,24 @@ class PseudoTtyProcess {
     getPid() {
         return this.childProcess.getPid();
     }
-    kill(s) {
+    async kill(s) {
         if (this.isAlive) {
-            try {
-                this.childProcess.kill(s || 'SIGTERM');
-            }
-            catch {
-                // when the child process completes before we explicitly call kill, this will throw
-                // do nothing
+            this.isAlive = false;
+            const pid = this.childProcess.getPid();
+            // Gracefully kill the entire process tree. This snapshots the tree
+            // BEFORE sending signals, so even if the root exits quickly from
+            // the signal, all descendants are already tracked and will be
+            // cleaned up (including any reparented to init/PID 1).
+            if (pid) {
+                await (0, native_1.killProcessTreeGraceful)(pid, s || 'SIGTERM');
             }
-            finally {
-                this.isAlive = false;
+            else {
+                try {
+                    this.childProcess.kill(s || 'SIGTERM');
+                }
+                catch {
+                    // child may have already exited
+                }
             }
         }
     }

package/dist/src/tasks-runner/running-tasks/batch-process.d.ts

@@ -15,5 +15,5 @@ export declare class BatchProcess {
     onOutput(cb: (output: string) => void): void;
     getResults(): Promise<BatchResults>;
     send(message: Serializable): void;
-    kill(signal?: NodeJS.Signals): void;
+    kill(signal?: NodeJS.Signals): Promise<void>;
 }

package/dist/src/tasks-runner/running-tasks/batch-process.js

@@ -1,8 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BatchProcess = void 0;
-const tslib_1 = require("tslib");
-const tree_kill_1 = tslib_1.__importDefault(require("tree-kill"));
+const native_1 = require("../../native");
 const exit_codes_1 = require("../../utils/exit-codes");
 const batch_messages_1 = require("../batch/batch-messages");
 class BatchProcess {
@@ -103,10 +102,9 @@ class BatchProcess {
     }
     kill(signal) {
         if (this.childProcess?.pid) {
-            (0, tree_kill_1.default)(this.childProcess.pid, signal, () => {
-                // Ignore errors - process may have already exited
-            });
+            return (0, native_1.killProcessTreeGraceful)(this.childProcess.pid, signal);
         }
+        return Promise.resolve();
     }
 }
 exports.BatchProcess = BatchProcess;

package/dist/src/tasks-runner/running-tasks/node-child-process.d.ts

@@ -18,7 +18,7 @@ export declare class NodeChildProcessWithNonDirectOutput implements RunningTask
         terminalOutput: string;
     }>;
     send(message: Serializable): void;
-    kill(signal?: NodeJS.Signals): void;
+    kill(signal?: NodeJS.Signals): Promise<void>;
 }
 export declare class NodeChildProcessWithDirectOutput implements RunningTask {
     private childProcess;
@@ -36,5 +36,5 @@ export declare class NodeChildProcessWithDirectOutput implements RunningTask {
     }>;
     waitForExit(): Promise<void>;
     getTerminalOutput(): string;
-    kill(signal?: NodeJS.Signals): void;
+    kill(signal?: NodeJS.Signals): Promise<void>;
 }

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

@@ -5,7 +5,7 @@ const tslib_1 = require("tslib");
 const pc = tslib_1.__importStar(require("picocolors"));
 const fs_1 = require("fs");
 const stream_1 = require("stream");
-const tree_kill_1 = tslib_1.__importDefault(require("tree-kill"));
+const native_1 = require("../../native");
 const exit_codes_1 = require("../../utils/exit-codes");
 const output_prefix_1 = require("./output-prefix");
 class NodeChildProcessWithNonDirectOutput {
@@ -97,10 +97,9 @@ class NodeChildProcessWithNonDirectOutput {
     }
     kill(signal) {
         if (this.childProcess?.pid) {
-            (0, tree_kill_1.default)(this.childProcess.pid, signal, () => {
-                // Ignore errors - process may have already exited
-            });
+            return (0, native_1.killProcessTreeGraceful)(this.childProcess.pid, signal);
         }
+        return Promise.resolve();
     }
 }
 exports.NodeChildProcessWithNonDirectOutput = NodeChildProcessWithNonDirectOutput;
@@ -168,10 +167,9 @@ class NodeChildProcessWithDirectOutput {
     }
     kill(signal) {
         if (this.childProcess?.pid) {
-            (0, tree_kill_1.default)(this.childProcess.pid, signal, () => {
-                // Ignore errors - process may have already exited
-            });
+            return (0, native_1.killProcessTreeGraceful)(this.childProcess.pid, signal);
         }
+        return Promise.resolve();
     }
 }
 exports.NodeChildProcessWithDirectOutput = NodeChildProcessWithDirectOutput;

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

@@ -166,6 +166,7 @@ export declare class TaskOrchestrator {
     private shouldCopyOutputsFromCacheBatch;
     private recordOutputsHashBatch;
     private handleContinuousTaskExit;
+    private isContinuousTaskNeeded;
     private completeContinuousTask;
     private cleanup;
     private performCleanup;

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

@@ -57,7 +57,12 @@ 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));
+        // `nx:noop` initiating tasks exit instantly via the fast-path in
+        // `spawnProcess`. If we treat the noop itself as the keep-alive anchor for
+        // its continuous dependencies, `cleanUpUnneededContinuousTasks` kills those
+        // children the moment the noop finishes. Expand through noops so the
+        // underlying real tasks become the anchors.
+        this.initializingTaskIds = (0, utils_1.expandInitiatingTasksThroughNoop)(this.initiatingTasks, this.taskGraph, this.projectGraph);
         this.processedTasks = new Map();
         this.completedTasks = new Map();
         this.waitingForTasks = [];
@@ -1071,11 +1076,21 @@ class TaskOrchestrator {
             const reason = stoppingReason === 'fulfilled' ? 'fulfilled' : 'interrupted';
             await this.completeContinuousTask(task, groupId, ownsRunningTasksService, reason);
         }
+        else if (!this.isContinuousTaskNeeded(task.id)) {
+            // No remaining tasks depend on this — the task was about to be
+            // killed by cleanUpUnneededContinuousTasks anyway.
+            await this.completeContinuousTask(task, groupId, ownsRunningTasksService, 'fulfilled');
+        }
         else {
             console.error(`Task "${task.id}" is continuous but exited with code ${code}`);
             await this.completeContinuousTask(task, groupId, ownsRunningTasksService, 'crashed');
         }
     }
+    isContinuousTaskNeeded(taskId) {
+        return this.tasksSchedule
+            .getIncompleteTasks()
+            .some((t) => this.taskGraph.continuousDependencies[t.id]?.includes(taskId));
+    }
     async completeContinuousTask(task, groupId, ownsRunningTasksService, reason) {
         if (this.completedTasks.has(task.id))
             return;
@@ -1129,9 +1144,11 @@ class TaskOrchestrator {
                 continue;
             await this.completeContinuousTask(task, groupId, ownsRunningTasksService, reason);
         }
-        // Kill all processes
-        this.forkedProcessTaskRunner.cleanup();
+        // Kill all processes — await forked runner cleanup for graceful shutdown
+        const forkedCleanup = this.forkedProcessTaskRunner.cleanup();
+        const continuousTaskIds = new Set(continuousSnapshot.map(([id]) => id));
         await Promise.all([
+            forkedCleanup,
             ...continuousSnapshot.map(async ([taskId, { runningTask }]) => {
                 try {
                     await runningTask.kill();
@@ -1148,7 +1165,10 @@ class TaskOrchestrator {
                     console.error(`Unable to terminate ${taskId}\nError:`, e);
                 }
             }),
-            ...Array.from(this.runningRunCommandsTasks).map(async ([taskId, t]) => {
+            // Skip tasks already killed via continuousSnapshot to avoid duplicate signals
+            ...Array.from(this.runningRunCommandsTasks)
+                .filter(([taskId]) => !continuousTaskIds.has(taskId))
+                .map(async ([taskId, t]) => {
                 try {
                     await t.kill();
                 }
@@ -1163,19 +1183,26 @@ class TaskOrchestrator {
         await Promise.all(this.discreteTaskExitHandled.values());
     }
     setupSignalHandlers() {
-        process.once('SIGINT', () => {
+        // Use process.on (not once) so the handler stays registered and absorbs
+        // re-raised signals from signal-exit. Without this, signal-exit's handler
+        // sees no remaining listeners after our once-handler auto-removes, and
+        // re-raises the signal — killing the process before async cleanup completes.
+        // The cleanup() idempotency guard (cleanupPromise) prevents double execution.
+        const handleSignal = (signal) => {
+            if (this.stopRequested)
+                return;
             this.stopRequested = true;
             if (!this.tuiEnabled) {
                 // Synchronously remove DB entries before async cleanup to prevent
                 // new nx processes from seeing stale "Waiting for ..." messages.
-                // This replicates the cleanup that process.exit() + Rust Drop
-                // previously provided.
                 for (const [taskId, { ownsRunningTasksService }] of this
                     .runningContinuousTasks) {
                     if (ownsRunningTasksService) {
                         this.runningTasksService?.removeRunningTask(taskId);
                     }
                 }
+            }
+            if (signal === 'SIGINT' && !this.tuiEnabled) {
                 // Silence output — pnpm (and similar wrappers) may exit before nx
                 // finishes cleanup, returning the shell prompt. Any output after
                 // that point would appear after the prompt.
@@ -1192,26 +1219,13 @@ class TaskOrchestrator {
                     this.resolveStopPromise();
                 }
                 else {
-                    process.exit((0, exit_codes_1.signalToCode)('SIGINT'));
-                }
-            });
-        });
-        process.once('SIGTERM', () => {
-            this.stopRequested = true;
-            this.cleanup().finally(() => {
-                if (this.resolveStopPromise) {
-                    this.resolveStopPromise();
+                    process.exit((0, exit_codes_1.signalToCode)(signal));
                 }
             });
-        });
-        process.once('SIGHUP', () => {
-            this.stopRequested = true;
-            this.cleanup().finally(() => {
-                if (this.resolveStopPromise) {
-                    this.resolveStopPromise();
-                }
-            });
-        });
+        };
+        process.on('SIGINT', () => handleSignal('SIGINT'));
+        process.on('SIGTERM', () => handleSignal('SIGTERM'));
+        process.on('SIGHUP', () => handleSignal('SIGHUP'));
     }
     cleanUpUnneededContinuousTasks() {
         const incompleteTasks = this.tasksSchedule.getIncompleteTasks();

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

@@ -31,6 +31,17 @@ export declare function getOutputsForTargetAndConfiguration(target: Task['target
 export declare function interpolate(template: string, data: any): string;
 export declare function getTargetConfigurationForTask(task: Task, projectGraph: ProjectGraph): TargetConfiguration | undefined;
 export declare function getExecutorNameForTask(task: Task, projectGraph: ProjectGraph): string;
+/**
+ * Expand a set of initiating task IDs by walking through any `nx:noop` tasks
+ * and replacing them with their direct dependencies + continuous dependencies.
+ * Non-noop tasks are kept as-is; cycles are safe.
+ *
+ * An `nx:noop` executor returns immediately, so if it is the only thing
+ * anchoring a continuous child, the child gets killed by
+ * `cleanUpUnneededContinuousTasks` the moment the noop completes. Treating the
+ * noop's dependencies as the real anchors preserves the intended orchestration.
+ */
+export declare function expandInitiatingTasksThroughNoop(initiatingTasks: Task[], taskGraph: TaskGraph, projectGraph: ProjectGraph): Set<string>;
 export declare function getExecutorForTask(task: Task, projects: Record<string, ProjectConfiguration>): ExecutorConfig & {
     isNgCompat: boolean;
     isNxExecutor: boolean;

package/dist/src/tasks-runner/utils.js

@@ -14,6 +14,7 @@ exports.getOutputsForTargetAndConfiguration = getOutputsForTargetAndConfiguratio
 exports.interpolate = interpolate;
 exports.getTargetConfigurationForTask = getTargetConfigurationForTask;
 exports.getExecutorNameForTask = getExecutorNameForTask;
+exports.expandInitiatingTasksThroughNoop = expandInitiatingTasksThroughNoop;
 exports.getExecutorForTask = getExecutorForTask;
 exports.getCustomHasher = getCustomHasher;
 exports.removeTasksFromTaskGraph = removeTasksFromTaskGraph;
@@ -291,6 +292,42 @@ function getTargetConfigurationForTask(task, projectGraph) {
 function getExecutorNameForTask(task, projectGraph) {
     return getTargetConfigurationForTask(task, projectGraph)?.executor;
 }
+/**
+ * Expand a set of initiating task IDs by walking through any `nx:noop` tasks
+ * and replacing them with their direct dependencies + continuous dependencies.
+ * Non-noop tasks are kept as-is; cycles are safe.
+ *
+ * An `nx:noop` executor returns immediately, so if it is the only thing
+ * anchoring a continuous child, the child gets killed by
+ * `cleanUpUnneededContinuousTasks` the moment the noop completes. Treating the
+ * noop's dependencies as the real anchors preserves the intended orchestration.
+ */
+function expandInitiatingTasksThroughNoop(initiatingTasks, taskGraph, projectGraph) {
+    const expanded = new Set();
+    const visited = new Set();
+    const queue = initiatingTasks.map((t) => t.id);
+    while (queue.length > 0) {
+        const taskId = queue.shift();
+        if (visited.has(taskId))
+            continue;
+        visited.add(taskId);
+        const task = taskGraph.tasks[taskId];
+        if (!task)
+            continue;
+        if (getExecutorNameForTask(task, projectGraph) === 'nx:noop') {
+            for (const dep of taskGraph.dependencies[taskId] ?? []) {
+                queue.push(dep);
+            }
+            for (const dep of taskGraph.continuousDependencies[taskId] ?? []) {
+                queue.push(dep);
+            }
+        }
+        else {
+            expanded.add(taskId);
+        }
+    }
+    return expanded;
+}
 function getExecutorForTask(task, projects) {
     const executor = projects[task.target.project]?.targets?.[task.target.target]?.executor;
     const [nodeModule, executorName] = (0, executor_utils_1.parseExecutor)(executor);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nx",
-  "version": "23.0.0-beta.1",
+  "version": "23.0.0-pr.33655.cdc3e72",
   "private": false,
   "type": "commonjs",
   "description": "The core Nx plugin contains the core functionality of Nx like the project graph, nx commands and task orchestration.",
@@ -146,7 +146,6 @@
     "supports-color": "7.2.0",
     "tar-stream": "2.2.0",
     "tmp": "0.2.4",
-    "tree-kill": "1.2.2",
     "tsconfig-paths": "4.2.0",
     "tslib": "2.8.1",
     "util-deprecate": "1.0.2",
@@ -171,16 +170,16 @@
     }
   },
   "optionalDependencies": {
-    "@nx/nx-darwin-arm64": "23.0.0-beta.1",
-    "@nx/nx-darwin-x64": "23.0.0-beta.1",
-    "@nx/nx-freebsd-x64": "23.0.0-beta.1",
-    "@nx/nx-linux-arm-gnueabihf": "23.0.0-beta.1",
-    "@nx/nx-linux-arm64-gnu": "23.0.0-beta.1",
-    "@nx/nx-linux-arm64-musl": "23.0.0-beta.1",
-    "@nx/nx-linux-x64-gnu": "23.0.0-beta.1",
-    "@nx/nx-linux-x64-musl": "23.0.0-beta.1",
-    "@nx/nx-win32-arm64-msvc": "23.0.0-beta.1",
-    "@nx/nx-win32-x64-msvc": "23.0.0-beta.1"
+    "@nx/nx-darwin-arm64": "23.0.0-pr.33655.cdc3e72",
+    "@nx/nx-darwin-x64": "23.0.0-pr.33655.cdc3e72",
+    "@nx/nx-freebsd-x64": "23.0.0-pr.33655.cdc3e72",
+    "@nx/nx-linux-arm-gnueabihf": "23.0.0-pr.33655.cdc3e72",
+    "@nx/nx-linux-arm64-gnu": "23.0.0-pr.33655.cdc3e72",
+    "@nx/nx-linux-arm64-musl": "23.0.0-pr.33655.cdc3e72",
+    "@nx/nx-linux-x64-gnu": "23.0.0-pr.33655.cdc3e72",
+    "@nx/nx-linux-x64-musl": "23.0.0-pr.33655.cdc3e72",
+    "@nx/nx-win32-arm64-msvc": "23.0.0-pr.33655.cdc3e72",
+    "@nx/nx-win32-x64-msvc": "23.0.0-pr.33655.cdc3e72"
   },
   "nx-migrations": {
     "migrations": "./migrations.json",