nx 23.0.0-beta.2 → 23.0.0-beta.21

package/dist/src/project-graph/utils/project-configuration-utils.js

@@ -169,11 +169,19 @@ function mergeCreateNodesResultsFromSinglePlugin(pluginResults, mergeFn, nodesMa
 /**
  * Merges create nodes results into a single rootMap.
  *
- * Default plugin results are merged twice: first into an intermediate
- * rootMap with unresolved spread sentinels preserved, so target
- * defaults selection sees the real merged shape of defaults; then
- * applied as a single layer onto the main rootMap where the preserved
- * spreads resolve against the specified + target-defaults base.
+ * Specified plugin results are merged once into the manager. Default
+ * plugin results are first staged into an intermediate rootMap (with
+ * `'...'` spreads deferred) so that synthesis can read each layer's
+ * contribution without re-running the merge. The synthetic result from
+ * `createTargetDefaultsResults` is then merged into the manager, and
+ * the staged intermediate is replayed on top — that replay is where
+ * deferred spreads expand against the final (specified + synth) base.
+ *
+ * Synthesis itself doesn't materialize a second rootMap. Per
+ * (root, target) it does an on-the-fly merge of the two layered
+ * contributions to learn the eventual executor/command, then matches
+ * defaults against that merged shape. This keeps specified-plugin
+ * merge work to a single pass.
  */
 function mergeCreateNodesResults(specifiedResults, defaultResults, nxJsonConfiguration, workspaceRoot, errors) {
     perf_hooks_1.performance.mark('createNodes:merge - start');
@@ -194,7 +202,7 @@ function mergeCreateNodesResults(specifiedResults, defaultResults, nxJsonConfigu
     for (const pluginResults of defaultResults) {
         mergeCreateNodesResultsFromSinglePlugin(pluginResults, mergeToIntermediate, nodesManager, intermediateDefaultRootMap, externalNodes, errors);
     }
-    const targetDefaultsResults = (0, target_defaults_1.createTargetDefaultsResults)(nodesManager.getRootMap(), intermediateDefaultRootMap, nxJsonConfiguration);
+    const targetDefaultsResults = (0, target_defaults_1.createTargetDefaultsResults)(nodesManager.getRootMap(), intermediateDefaultRootMap, nxJsonConfiguration, configurationSourceMaps, defaultConfigurationSourceMaps);
     if (targetDefaultsResults.length > 0) {
         mergeCreateNodesResultsFromSinglePlugin(targetDefaultsResults, mergeToManager, nodesManager, nodesManager.getRootMap(), externalNodes, errors);
     }

package/dist/src/project-graph/utils/retrieve-workspace-files.js

@@ -65,7 +65,7 @@ async function retrieveProjectConfigurationsWithAngularProjects(workspaceRoot, n
             (typeof p === 'object' && p.plugin === angular_json_1.NX_ANGULAR_JSON_PLUGIN_NAME))) {
         pluginsToLoad.push((0, path_1.join)(__dirname, '../../adapter/angular-json'));
     }
-    const separatedPlugins = await (0, get_plugins_1.getPluginsSeparated)(workspaceRoot);
+    const separatedPlugins = await (0, get_plugins_1.getPluginsSeparated)(nxJson, workspaceRoot);
     const res = await retrieveProjectConfigurations(separatedPlugins, workspaceRoot, nxJson);
     return res;
 }

package/dist/src/tasks-runner/create-task-graph.d.ts

@@ -16,16 +16,16 @@ export declare class ProcessTasks {
     };
     private readonly allTargetNames;
     constructor(extraTargetDependencies: TargetDependencies, projectGraph: ProjectGraph);
-    processTasks(projectNames: string[], targets: string[], configuration: string, overrides: Object, excludeTaskDependencies: boolean): string[];
-    processTask(task: Task, projectUsedToDeriveDependencies: string, configuration: string, overrides: Object): void;
+    processTasks(projectNames: string[], targets: string[], configuration: string, overrides: Record<string, unknown>, excludeTaskDependencies: boolean): string[];
+    processTask(task: Task, projectUsedToDeriveDependencies: string, configuration: string, overrides: Record<string, unknown>): void;
     private processTasksForMultipleProjects;
     private processTasksForSingleProject;
     private processTasksForDependencies;
     private createDummyTask;
-    createTask(id: string, project: ProjectGraphProjectNode, target: string, resolvedConfiguration: string | undefined, overrides: Object): Task;
+    createTask(id: string, project: ProjectGraphProjectNode, target: string, resolvedConfiguration: string | undefined, overrides: Record<string, unknown>): Task;
     resolveConfiguration(project: ProjectGraphProjectNode, target: string, configuration: string | undefined): string;
 }
-export declare function createTaskGraph(projectGraph: ProjectGraph, extraTargetDependencies: TargetDependencies, projectNames: string[], targets: string[], configuration: string | undefined, overrides: Object, excludeTaskDependencies?: boolean): TaskGraph;
+export declare function createTaskGraph(projectGraph: ProjectGraph, extraTargetDependencies: TargetDependencies, projectNames: string[], targets: string[], configuration: string | undefined, overrides: Record<string, unknown>, excludeTaskDependencies?: boolean): TaskGraph;
 export declare function mapTargetDefaultsToDependencies(defaults: TargetDefaults | undefined): TargetDependencies;
 /**
  * This function is used to filter out the dummy tasks from the dependencies

package/dist/src/tasks-runner/create-task-graph.js

@@ -205,7 +205,7 @@ class ProcessTasks {
             projectRoot: project.data.root,
             overrides: interpolatedOverrides,
             outputs: (0, utils_1.getOutputs)(this.projectGraph.nodes, qualifiedTarget, interpolatedOverrides),
-            cache: project.data.targets[target].cache,
+            cache: project.data.targets[target].cache ?? false,
             parallelism: project.data.targets[target].parallelism ?? true,
             continuous: project.data.targets[target].continuous ?? false,
         };

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

@@ -12,8 +12,6 @@ export declare abstract class RemoteCacheV2 {
 }
 export interface DefaultTasksRunnerOptions {
     parallel?: number;
-    cacheableOperations?: string[];
-    cacheableTargets?: string[];
     runtimeCacheInputs?: string[];
     cacheDirectory?: string;
     remoteCache?: RemoteCache;

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,19 @@ 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
+        // No SIGINT/SIGTERM/SIGHUP handlers here. The orchestrator's
+        // setupSignalHandlers() owns signal dispatch and calls FPTR.cleanup()
+        // in the direct path; in the forked path the process is detached
+        // and never receives these signals from the OS.
     }
 }
 exports.ForkedProcessTaskRunner = ForkedProcessTaskRunner;

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

@@ -1,22 +1,7 @@
 import type { NxJsonConfiguration } from '../config/nx-json';
-import { NxArgs } from '../utils/command-line-utils';
 import { Task, TaskGraph } from '../config/task-graph';
 import { LifeCycle, TaskResult } from './life-cycle';
 import type { ProjectGraph } from '../config/project-graph';
 import { RunningTask } from './running-tasks/running-task';
-/**
- * This function is deprecated. Do not use this
- * @deprecated This function is deprecated. Do not use this
- */
-export declare function initTasksRunner(nxArgs: NxArgs): Promise<{
-    invoke: (opts: {
-        tasks: Task[];
-        parallel: number;
-    }) => Promise<{
-        status: NodeJS.Process["exitCode"];
-        taskGraph: TaskGraph;
-        taskResults: Record<string, TaskResult>;
-    }>;
-}>;
 export declare function runDiscreteTasks(tasks: Task[], projectGraph: ProjectGraph, taskGraphForHashing: TaskGraph, nxJson: NxJsonConfiguration, lifeCycle: LifeCycle): Promise<Array<Promise<TaskResult[]>>>;
 export declare function runContinuousTasks(tasks: Task[], projectGraph: ProjectGraph, taskGraphForHashing: TaskGraph, nxJson: NxJsonConfiguration, lifeCycle: LifeCycle): Promise<Record<string, Promise<RunningTask>>>;

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

@@ -1,78 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.initTasksRunner = initTasksRunner;
 exports.runDiscreteTasks = runDiscreteTasks;
 exports.runContinuousTasks = runContinuousTasks;
-const nx_json_1 = require("../config/nx-json");
-const project_graph_1 = require("../project-graph/project-graph");
 const run_command_1 = require("./run-command");
 const invoke_runner_terminal_output_life_cycle_1 = require("./life-cycles/invoke-runner-terminal-output-life-cycle");
-const perf_hooks_1 = require("perf_hooks");
-const utils_1 = require("./utils");
 const dotenv_1 = require("../utils/dotenv");
 const life_cycle_1 = require("./life-cycle");
 const task_orchestrator_1 = require("./task-orchestrator");
 const create_task_hasher_1 = require("../hasher/create-task-hasher");
 const client_1 = require("../daemon/client/client");
 const task_results_life_cycle_1 = require("./life-cycles/task-results-life-cycle");
-/**
- * This function is deprecated. Do not use this
- * @deprecated This function is deprecated. Do not use this
- */
-async function initTasksRunner(nxArgs) {
-    perf_hooks_1.performance.mark('init-local');
-    (0, dotenv_1.loadRootEnvFiles)();
-    const nxJson = (0, nx_json_1.readNxJson)();
-    if (nxArgs.verbose) {
-        process.env.NX_VERBOSE_LOGGING = 'true';
-    }
-    const projectGraph = await (0, project_graph_1.createProjectGraphAsync)({ exitOnError: true });
-    return {
-        invoke: async (opts) => {
-            perf_hooks_1.performance.mark('code-loading:end');
-            // TODO: This polyfills the outputs if someone doesn't pass a task with outputs. Remove this in Nx 20
-            opts.tasks.forEach((t) => {
-                if (!t.outputs) {
-                    t.outputs = (0, utils_1.getOutputs)(projectGraph.nodes, t.target, t.overrides);
-                }
-            });
-            const lifeCycle = new invoke_runner_terminal_output_life_cycle_1.InvokeRunnerTerminalOutputLifeCycle(opts.tasks);
-            const taskGraph = {
-                roots: opts.tasks.map((task) => task.id),
-                tasks: opts.tasks.reduce((acc, task) => {
-                    acc[task.id] = task;
-                    return acc;
-                }, {}),
-                dependencies: opts.tasks.reduce((acc, task) => {
-                    acc[task.id] = [];
-                    return acc;
-                }, {}),
-                continuousDependencies: opts.tasks.reduce((acc, task) => {
-                    acc[task.id] = [];
-                    return acc;
-                }, {}),
-            };
-            const taskResults = await (0, run_command_1.invokeTasksRunner)({
-                tasks: opts.tasks,
-                projectGraph,
-                taskGraph,
-                lifeCycle,
-                nxJson,
-                nxArgs: { ...nxArgs, parallel: opts.parallel },
-                loadDotEnvFiles: true,
-                initiatingProject: null,
-                initiatingTasks: [],
-            });
-            return {
-                status: Object.values(taskResults).some((taskResult) => taskResult.status === 'failure' || taskResult.status === 'skipped')
-                    ? 1
-                    : 0,
-                taskGraph,
-                taskResults,
-            };
-        },
-    };
-}
 async function createOrchestrator(tasks, projectGraph, taskGraphForHashing, nxJson, lifeCycle) {
     (0, dotenv_1.loadRootEnvFiles)();
     const invokeRunnerTerminalLifecycle = new invoke_runner_terminal_output_life_cycle_1.InvokeRunnerTerminalOutputLifeCycle(tasks);

package/dist/src/tasks-runner/legacy-depends-on-warning.d.ts

@@ -0,0 +1,18 @@
+import { TargetDependencyConfig } from '../config/workspace-json-project-json';
+type LegacyValue = 'self' | 'dependencies';
+type LegacyEntry = TargetDependencyConfig & {
+    projects: LegacyValue;
+};
+export interface LegacyDependsOnViolation {
+    index: number;
+    originalEntry: LegacyEntry;
+}
+export interface LegacyDependsOnLocation {
+    ownerTarget?: string;
+    index?: number;
+    legacyViolations?: LegacyDependsOnViolation[];
+}
+export declare function warnLegacyDependsOnMagicString(currentProject: string | undefined, dependencyConfig: TargetDependencyConfig, location: LegacyDependsOnLocation | undefined): void;
+export declare function flushLegacyDependsOnViolations(project: string, ownerTarget: string, violations: LegacyDependsOnViolation[], projectRoot: string | undefined): void;
+export declare function __resetForTests(): void;
+export {};

package/dist/src/tasks-runner/legacy-depends-on-warning.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.warnLegacyDependsOnMagicString = warnLegacyDependsOnMagicString;
+exports.flushLegacyDependsOnViolations = flushLegacyDependsOnViolations;
+exports.__resetForTests = __resetForTests;
+const nx_deps_cache_1 = require("../project-graph/nx-deps-cache");
+const source_maps_1 = require("../project-graph/utils/project-configuration/source-maps");
+const output_1 = require("../utils/output");
+const warned = new Set();
+const isInternal = (p) => !p || p.startsWith('nx/');
+// Callers gate this on `dependencyConfig.projects` already being a legacy value;
+// the inner cast snapshots that runtime guarantee into the type system.
+function warnLegacyDependsOnMagicString(currentProject, dependencyConfig, location) {
+    const violation = {
+        index: location?.index ?? -1,
+        originalEntry: { ...dependencyConfig },
+    };
+    // Collector-aware caller (`getDependencyConfigs`) batches violations so the
+    // warning can group all offending entries for a single target. External
+    // callers fall through to an immediate per-entry warning.
+    if (location?.legacyViolations)
+        return void location.legacyViolations.push(violation);
+    flushLegacyDependsOnViolations(currentProject ?? '<unknown>', location?.ownerTarget ?? '<unknown>', [violation], undefined);
+}
+function flushLegacyDependsOnViolations(project, ownerTarget, violations, projectRoot) {
+    if (violations.length === 0)
+        return;
+    // Read source maps fresh each flush so daemon-cached maps don't go stale;
+    // only runs when violations exist, which is rare.
+    let sourceMaps = null;
+    try {
+        sourceMaps = (0, nx_deps_cache_1.readSourceMapsCache)();
+    }
+    catch { } // best-effort context
+    const map = projectRoot && sourceMaps ? sourceMaps[projectRoot] : undefined;
+    const arrayKey = `targets.${ownerTarget}.dependsOn`;
+    const items = violations.map((v) => {
+        const info = map
+            ? (0, source_maps_1.readArrayItemSourceInfo)(map, arrayKey, v.index)
+            : undefined;
+        return {
+            ...v,
+            value: v.originalEntry.projects,
+            plugin: info?.[1],
+            file: info?.[0] ?? undefined,
+        };
+    });
+    const shared = (key) => items.every((i) => i[key] === items[0][key]) ? items[0][key] : null;
+    const value = shared('value');
+    const plugin = shared('plugin');
+    const file = shared('file');
+    // External-plugin warnings are workspace-wide (the plugin's behavior, not a
+    // specific config): dedupe per (plugin, value) so the user sees one warning
+    // per offending plugin, not one per affected target.
+    const dedupeKey = plugin && !isInternal(plugin) && value
+        ? `plugin::${plugin}::${value}`
+        : `target::${project}::${ownerTarget}`;
+    if (warned.has(dedupeKey))
+        return;
+    warned.add(dedupeKey);
+    const n = items.length;
+    const word = n === 1 ? 'entry' : 'entries';
+    const deprecation = 'This is deprecated and will be removed in Nx v24 —';
+    let phrase;
+    if (value) {
+        phrase = `projects: '${value}'`;
+    }
+    else {
+        const self = items.filter((i) => i.value === 'self').length;
+        phrase = `legacy projects values (${self} 'self', ${n - self} 'dependencies')`;
+    }
+    let title;
+    let suppressBody = false;
+    if (plugin && !isInternal(plugin)) {
+        // Single external plugin: same plugin emits the same value across projects.
+        title = `The ${plugin} plugin infers dependsOn entries using ${phrase}. ${deprecation} please upgrade ${plugin} to a version that doesn't emit this.`;
+        suppressBody = true;
+    }
+    else if (plugin && isInternal(plugin) && file) {
+        // Single hand-authored config file — lead with the file path.
+        title = `${file} defines ${project}:${ownerTarget} with ${n} dependsOn ${word} using ${phrase}. ${deprecation} run 'nx repair' to fix this.`;
+    }
+    else {
+        // Mixed sources or no source-map info — tailor advice to what's offending.
+        const offending = Array.from(new Set(items
+            .filter((i) => i.plugin && !isInternal(i.plugin))
+            .map((i) => i.plugin)));
+        const origin = plugin
+            ? ` (set by ${plugin}${file ? ` in ${file}` : ''})`
+            : '';
+        const advice = offending.length
+            ? `run 'nx repair' for hand-authored entries and upgrade ${offending.join(', ')} for plugin-inferred entries`
+            : `run 'nx repair' to fix`;
+        title = `${project}:${ownerTarget} has ${n} dependsOn ${word} using ${phrase}${origin}. ${deprecation} ${advice}.`;
+    }
+    const bodyLines = suppressBody
+        ? []
+        : items.map((i) => {
+            const src = i.plugin && !plugin
+                ? ` from ${i.plugin}${i.file ? ` in ${i.file}` : ''}`
+                : '';
+            return `  - ${JSON.stringify(i.originalEntry)} (${i.index}${src})`;
+        });
+    output_1.output.warn({ title, bodyLines });
+}
+// Test-only: clears the process-wide dedupe set.
+function __resetForTests() {
+    warned.clear();
+}

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

@@ -1,19 +1,18 @@
 import { Task } from '../config/task-graph';
-import { BatchInfo, BatchStatus, ExternalObject, TaskStatus as NativeTaskStatus } from '../native';
+import { BatchInfo, BatchStatus, ExternalObject, TaskResult, TaskStatus as NativeTaskStatus } from '../native';
 import { TaskStatus } from './tasks-runner';
 /**
- * The result of a completed {@link Task}
+ * The result of a completed {@link Task}.
+ *
+ * Defined as a Rust struct in `packages/nx/src/native/tasks/types.rs` and
+ * exposed to TypeScript via NAPI. Re-exported here so existing imports
+ * keep working.
  *
  * Task timing information (start and end timestamps) is available
  * on the {@link Task} object itself via {@link Task.startTime} and
  * {@link Task.endTime}.
  */
-export interface TaskResult {
-    task: Task;
-    status: TaskStatus;
-    code: number;
-    terminalOutput?: string;
-}
+export type { TaskResult };
 /**
  * A map of {@link TaskResult} keyed by the ID of the completed {@link Task}s
  */

package/dist/src/tasks-runner/life-cycles/invoke-runner-terminal-output-life-cycle.js

@@ -13,9 +13,10 @@ class InvokeRunnerTerminalOutputLifeCycle {
         output_1.output.log({
             color: 'cyan',
             title: `Running ${this.tasks.length} tasks:`,
-            bodyLines: this.tasks.map((task) => `- Task ${task.id} ${task.overrides.__overrides_unparsed__.length > 0
-                ? `Overrides: ${task.overrides.__overrides_unparsed__.join(' ')}`
-                : ''}`),
+            bodyLines: this.tasks.map((task) => {
+                const unparsed = (0, utils_1.getUnparsedOverrideArgs)(task);
+                return `- Task ${task.id} ${unparsed.length > 0 ? `Overrides: ${unparsed.join(' ')}` : ''}`;
+            }),
         });
         output_1.output.addVerticalSeparatorWithoutNewLines('cyan');
     }
@@ -24,9 +25,8 @@ class InvokeRunnerTerminalOutputLifeCycle {
         const taskIds = this.tasks.map((task) => {
             const cached = this.cachedTasks.indexOf(task) !== -1;
             const failed = this.failedTasks.indexOf(task) !== -1;
-            return `- Task ${task.id} ${task.overrides.__overrides_unparsed__.length > 0
-                ? `Overrides: ${task.overrides.__overrides_unparsed__.join(' ')}`
-                : ''} ${cached ? 'CACHED' : ''} ${failed ? 'FAILED' : ''}`;
+            const unparsed = (0, utils_1.getUnparsedOverrideArgs)(task);
+            return `- Task ${task.id} ${unparsed.length > 0 ? `Overrides: ${unparsed.join(' ')}` : ''} ${cached ? 'CACHED' : ''} ${failed ? 'FAILED' : ''}`;
         });
         if (this.failedTasks.length === 0) {
             output_1.output.addVerticalSeparatorWithoutNewLines('green');

package/dist/src/tasks-runner/life-cycles/task-history-life-cycle-old.js

@@ -61,11 +61,22 @@ class LegacyTaskHistoryLifeCycle {
     }
     printFlakyTasksMessage() {
         if (this.flakyTasks?.length > 0) {
+            const MAX_VISIBLE_FLAKY = 5;
+            const visibleFlaky = this.flakyTasks.length > MAX_VISIBLE_FLAKY + 1
+                ? this.flakyTasks.slice(0, MAX_VISIBLE_FLAKY)
+                : this.flakyTasks;
+            const hiddenCount = this.flakyTasks.length - visibleFlaky.length;
+            const flakyRows = visibleFlaky.map((t) => `  ${t}`);
+            if (hiddenCount > 0) {
+                flakyRows.push(`  ${hiddenCount} more...`);
+            }
             output_1.output.warn({
-                title: `Nx detected ${this.flakyTasks.length === 1 ? 'a flaky task' : ' flaky tasks'}`,
+                title: `Nx detected ${this.flakyTasks.length === 1
+                    ? 'a flaky task'
+                    : `${this.flakyTasks.length} flaky tasks`}`,
                 bodyLines: [
                     ,
-                    ...this.flakyTasks.map((t) => `  ${t}`),
+                    ...flakyRows,
                     ...((0, nx_cloud_utils_1.isNxCloudUsed)((0, nx_json_1.readNxJson)())
                         ? []
                         : [

package/dist/src/tasks-runner/life-cycles/task-history-life-cycle.js

@@ -79,14 +79,25 @@ class TaskHistoryLifeCycle {
     }
     printFlakyTasksMessage() {
         if (this.flakyTasks?.length > 0) {
+            const MAX_VISIBLE_FLAKY = 5;
+            const visibleFlaky = this.flakyTasks.length > MAX_VISIBLE_FLAKY + 1
+                ? this.flakyTasks.slice(0, MAX_VISIBLE_FLAKY)
+                : this.flakyTasks;
+            const hiddenCount = this.flakyTasks.length - visibleFlaky.length;
+            const flakyRows = visibleFlaky.map((hash) => {
+                const taskRun = this.taskRuns.get(hash);
+                return `  ${(0, serialize_target_1.serializeTarget)(taskRun.target.project, taskRun.target.target, taskRun.target.configuration)}`;
+            });
+            if (hiddenCount > 0) {
+                flakyRows.push(`  ${hiddenCount} more...`);
+            }
             output_1.output.warn({
-                title: `Nx detected ${this.flakyTasks.length === 1 ? 'a flaky task' : ' flaky tasks'}`,
+                title: `Nx detected ${this.flakyTasks.length === 1
+                    ? 'a flaky task'
+                    : `${this.flakyTasks.length} flaky tasks`}`,
                 bodyLines: [
                     ,
-                    ...this.flakyTasks.map((hash) => {
-                        const taskRun = this.taskRuns.get(hash);
-                        return `  ${(0, serialize_target_1.serializeTarget)(taskRun.target.project, taskRun.target.target, taskRun.target.configuration)}`;
-                    }),
+                    ...flakyRows,
                     ...((0, nx_cloud_utils_1.isNxCloudUsed)((0, nx_json_1.readNxJson)())
                         ? []
                         : [

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

@@ -67,6 +67,12 @@ function getTuiTerminalSummaryLifeCycle({ projectNames, tasks, taskGraph, args,
             displayStoppedTasks.add(taskId);
             inProgressTasks.delete(taskId);
         }
+        else if (taskStatus === 2 /* NativeTaskStatus.Skipped */) {
+            // Skipped tasks don't get an endTasks() call; clear them here so the run
+            // summary doesn't treat them as still-in-progress and report Cancelled.
+            tasksToTaskStatus[taskId] = 'skipped';
+            inProgressTasks.delete(taskId);
+        }
     };
     lifeCycle.endTasks = (taskResults) => {
         for (const { task, status, terminalOutput } of taskResults) {
@@ -132,10 +138,13 @@ function getTuiTerminalSummaryLifeCycle({ projectNames, tasks, taskGraph, args,
         (0, task_history_life_cycle_1.getTasksHistoryLifeCycle)().printFlakyTasksMessage();
     };
     const printRunOneSummary = ({ failure, cancelled, }) => {
-        // Prints task outputs in the order they were completed
-        // above the summary, since run-one should print all task results.
+        // Print task outputs in completion order above the summary.
         for (const taskId of taskIdsInTheOrderTheyStart) {
             const taskStatus = tasksToTaskStatus[taskId];
+            // Skipped tasks never ran; don't print a misleading `> nx run` header.
+            if (taskStatus === 'skipped') {
+                continue;
+            }
             const terminalOutput = getTerminalOutput(taskId);
             output_1.output.logCommandOutput(taskId, taskStatus, terminalOutput);
         }

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/run-command.js

@@ -22,6 +22,7 @@ const project_graph_1 = require("../project-graph/project-graph");
 const handle_errors_1 = require("../utils/handle-errors");
 const is_ci_1 = require("../utils/is-ci");
 const nx_cloud_utils_1 = require("../utils/nx-cloud-utils");
+const logger_1 = require("../utils/logger");
 const nx_key_1 = require("../utils/nx-key");
 const output_1 = require("../utils/output");
 const sync_generators_1 = require("../utils/sync-generators");
@@ -324,6 +325,10 @@ async function runCommand(projectsToRun, currentProjectGraph, { nxJson }, nxArgs
     return status;
 }
 async function runCommandForTasks(projectsToRun, currentProjectGraph, { nxJson }, nxArgs, overrides, initiatingProject, extraTargetDependencies, extraOptions) {
+    // Kick off the license lookup in the background so it overlaps with task
+    // execution. The log itself is deferred to the print site below so it
+    // never lands in the middle of task output.
+    const nxKeyPromise = (0, nx_key_1.getNxKeyInformation)().catch(() => null);
     const projectNames = projectsToRun.map((t) => t.name);
     const projectNameSet = new Set(projectNames);
     const { projectGraph, taskGraph } = await ensureWorkspaceIsInSyncAndGetGraphs(currentProjectGraph, nxJson, projectNames, nxArgs, overrides, extraTargetDependencies, extraOptions);
@@ -348,7 +353,9 @@ async function runCommandForTasks(projectsToRun, currentProjectGraph, { nxJson }
             printSummary();
         }
         await printConfigureAiAgentsDisclaimer();
-        await (0, nx_key_1.printNxKey)();
+        const nxKey = await nxKeyPromise;
+        if (nxKey)
+            logger_1.logger.log((0, nx_key_1.createNxKeyLicenseeInformation)(nxKey));
         return {
             taskResults,
             completed: didCommandComplete(tasks, taskResults),
@@ -826,12 +833,6 @@ function getTasksRunnerPath(runner, nxJson) {
         : defaultTasksRunnerPath;
 }
 function getRunnerOptions(runner, nxJson, nxArgs, isCloudDefault) {
-    const defaultCacheableOperations = [];
-    for (const key in nxJson.targetDefaults) {
-        if (nxJson.targetDefaults[key].cache) {
-            defaultCacheableOperations.push(key);
-        }
-    }
     const result = {
         ...nxJson.tasksRunnerOptions?.[runner]?.options,
         ...nxArgs,
@@ -858,10 +859,6 @@ function getRunnerOptions(runner, nxJson, nxArgs, isCloudDefault) {
     if (nxJson.cacheDirectory) {
         result.cacheDirectory ??= nxJson.cacheDirectory;
     }
-    if (defaultCacheableOperations.length) {
-        result.cacheableOperations ??= [];
-        result.cacheableOperations = result.cacheableOperations.concat(defaultCacheableOperations);
-    }
     if (nxJson.useDaemonProcess !== undefined) {
         result.useDaemonProcess ??= nxJson.useDaemonProcess;
     }

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>;
 }