nx 23.1.0 → 23.1.2

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

@@ -13,10 +13,10 @@ const delayed_spinner_1 = require("../../utils/delayed-spinner");
 const plugin_progress_text_1 = require("../../utils/plugin-progress-text");
 const progress_topics_1 = require("../../utils/progress-topics");
 const error_types_1 = require("../error-types");
-const source_maps_1 = require("./project-configuration/source-maps");
 const target_defaults_1 = require("./project-configuration/target-defaults");
 var target_merging_1 = require("./project-configuration/target-merging");
 Object.defineProperty(exports, "mergeTargetConfigurations", { enumerable: true, get: function () { return target_merging_1.mergeTargetConfigurations; } });
+const target_merging_2 = require("./project-configuration/target-merging");
 var target_defaults_2 = require("./project-configuration/target-defaults");
 Object.defineProperty(exports, "readTargetDefaultsForTarget", { enumerable: true, get: function () { return target_defaults_2.readTargetDefaultsForTarget; } });
 /**
@@ -123,14 +123,13 @@ async function createProjectConfigurationsWithPlugins(root = workspace_root_1.wo
  * Runs a single plugin batch through two passes:
  *
  * 1. Every project node in every plugin result is handed to `mergeFn`,
- *    which decides where it lands (the manager's rootMap, an
- *    intermediate rootMap, etc.). Any failure is collected into
- *    `errors`; processing keeps going. External nodes are accumulated
- *    onto the shared `externalNodes` record.
+ *    which merges it into the manager's rootMap. Any failure is
+ *    collected into `errors`; processing keeps going. External nodes
+ *    are accumulated onto the shared `externalNodes` record.
  * 2. After every project in the batch has been merged, name-reference
- *    sentinels for the batch are registered against `nameRefRootMap` —
- *    the rootMap the batch was merged into — so sentinels point at the
- *    target objects that actually received the merges.
+ *    sentinels for the batch are registered against the manager's
+ *    rootMap, so sentinels point at the target objects that actually
+ *    received the merges.
  *
  * The two passes can't be collapsed: a sentinel registered too early
  * would point at the pre-merge object, and a later project in the same
@@ -138,7 +137,11 @@ async function createProjectConfigurationsWithPlugins(root = workspace_root_1.wo
  * the registration into a second pass also lets forward references
  * inside the same batch resolve eagerly.
  */
-function mergeCreateNodesResultsFromSinglePlugin(pluginResults, mergeFn, nodesManager, nameRefRootMap, externalNodes, errors) {
+function mergeCreateNodesResultsFromSinglePlugin(pluginResults, mergeFn, nodesManager, externalNodes, errors) {
+    mergeSinglePluginResults(pluginResults, mergeFn, externalNodes, errors);
+    registerNameRefsFromSinglePlugin(pluginResults, nodesManager, errors);
+}
+function mergeSinglePluginResults(pluginResults, mergeFn, externalNodes, errors) {
     for (const result of pluginResults) {
         const [pluginName, file, nodes, pluginIndex] = result;
         const { projects: projectNodes, externalNodes: pluginExternalNodes } = nodes;
@@ -156,11 +159,13 @@ function mergeCreateNodesResultsFromSinglePlugin(pluginResults, mergeFn, nodesMa
         }
         Object.assign(externalNodes, pluginExternalNodes);
     }
+}
+function registerNameRefsFromSinglePlugin(pluginResults, nodesManager, errors) {
     for (const result of pluginResults) {
         const [pluginName, file, nodes, pluginIndex] = result;
         const { projects: projectNodes } = nodes;
         try {
-            nodesManager.registerNameRefs(projectNodes, nameRefRootMap);
+            nodesManager.registerNameRefs(projectNodes);
         }
         catch (error) {
             errors.push(new error_types_1.MergeNodesError({ file, pluginName, error, pluginIndex }));
@@ -170,110 +175,83 @@ function mergeCreateNodesResultsFromSinglePlugin(pluginResults, mergeFn, nodesMa
 /**
  * Merges create nodes results into a single rootMap.
  *
- * 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.
+ * Every layer merges into the manager through the same source-map-aware
+ * merge, in precedence order:
+ *
+ *   specified plugins → synthetic target defaults → default plugins
+ *
+ * so field-level provenance is decided by the merge itself for all three
+ * layers — whichever layer a field's final value came from owns its
+ * attribution, and `'...'` spreads in default-plugin configs resolve against
+ * the accumulated specified + target-defaults 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.
+ * Target-default synthesis needs the *merged* shape of the default layer
+ * (to predict each target's eventual executor/command) before that layer
+ * merges into the manager. To get it, default results are first staged into
+ * a throwaway intermediate rootMap with unresolvable `'...'` spreads
+ * deferred. The staging output feeds only `createTargetDefaultsResults`; the
+ * default plugins then merge into the manager from their original results.
  */
 function mergeCreateNodesResults(specifiedResults, defaultResults, nxJsonConfiguration, workspaceRoot, errors) {
     perf_hooks_1.performance.mark('createNodes:merge - start');
     const nodesManager = new project_nodes_manager_1.ProjectNodesManager();
     const externalNodes = {};
     const configurationSourceMaps = {};
-    const intermediateDefaultRootMap = {};
-    // Kept separate so the intermediate merge doesn't clobber
-    // specified/TD attribution on fields the defaults don't touch.
-    const defaultConfigurationSourceMaps = {};
     const mergeToManager = (project, sourceInfo) => nodesManager.mergeProjectNode(project, configurationSourceMaps, sourceInfo);
-    const mergeToIntermediate = (project, sourceInfo) => {
-        (0, project_nodes_manager_1.mergeProjectConfigurationIntoRootMap)(intermediateDefaultRootMap, project, defaultConfigurationSourceMaps, sourceInfo);
-    };
     for (const pluginResults of specifiedResults) {
-        mergeCreateNodesResultsFromSinglePlugin(pluginResults, mergeToManager, nodesManager, nodesManager.getRootMap(), externalNodes, errors);
-    }
-    for (const pluginResults of defaultResults) {
-        mergeCreateNodesResultsFromSinglePlugin(pluginResults, mergeToIntermediate, nodesManager, intermediateDefaultRootMap, externalNodes, errors);
-    }
-    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);
+        mergeCreateNodesResultsFromSinglePlugin(pluginResults, mergeToManager, nodesManager, externalNodes, errors);
     }
-    // Apply the intermediate default rootMap as a single layer. Preserved
-    // spread sentinels resolve here against the real specified + TD base.
-    // Source maps are intentionally not written — TD attribution for
-    // fields that yield to the base (e.g. keys before `...`) stays intact.
-    for (const root in intermediateDefaultRootMap) {
-        const project = intermediateDefaultRootMap[root];
-        try {
-            nodesManager.mergeProjectNode(project, undefined, undefined);
+    // Without target defaults there is nothing to synthesize, and the staging
+    // pass exists only to feed synthesis — skip straight to the default-plugin
+    // merge.
+    if (Object.keys(nxJsonConfiguration.targetDefaults ?? {}).length > 0) {
+        // Throwaway staging area: the default layer's merged shape (unresolvable
+        // `'...'` spreads deferred), read only by target-default synthesis. The
+        // default plugins merge into the manager from their original results, not
+        // from this map. No source maps are kept for it — synthesis attributes
+        // targets without them (a default plugin can never be named by a
+        // `filter.plugin`); the real default merge writes the manager's.
+        const intermediateDefaultRootMap = {};
+        // The rootMap merge adopts input arrays/objects by reference and grows
+        // them in place (e.g. `mergeMetadata`), so staging works on deep clones —
+        // handing it the plugin results themselves would corrupt them before the
+        // real merge below reads them.
+        const mergeToIntermediate = (project, sourceInfo) => {
+            (0, project_nodes_manager_1.mergeProjectConfigurationIntoRootMap)(intermediateDefaultRootMap, (0, target_merging_2.deepClone)(project), undefined, sourceInfo, false, true);
+        };
+        // Stage the default layer for synthesis. Merge errors are discarded and
+        // external nodes land in a scratch object — the same results merge into
+        // the manager below, where both surface once with proper plugin context.
+        // The discard is safe because every merge throw is base-independent in
+        // both its condition and its reachability: each throw's condition reads
+        // only the plugin's own config, and the spread-ambiguity throws fire even
+        // when a key is dropped by a base-owns-key shortcut, because those
+        // shortcuts eagerly validate the dropped value (`assertNoIntegerLikeSpreadKey`).
+        // So a given config raises the same error in this pass and the real merge
+        // below despite their bases differing.
+        // Name references are NOT registered here: `applySubstitutions` sweeps only
+        // the manager's `rootMap`, so sentinels registered against this throwaway
+        // rootMap would never be visited and would never resolve.
+        const stagingErrors = [];
+        const stagingExternalNodes = {};
+        for (const pluginResults of defaultResults) {
+            mergeSinglePluginResults(pluginResults, mergeToIntermediate, stagingExternalNodes, stagingErrors);
         }
-        catch (error) {
-            errors.push(new error_types_1.MergeNodesError({
-                file: 'nx.json',
-                pluginName: 'nx/default-plugins',
-                error,
-                pluginIndex: undefined,
-            }));
+        const targetDefaultsResults = (0, target_defaults_1.createTargetDefaultsResults)(nodesManager.getRootMap(), intermediateDefaultRootMap, nxJsonConfiguration, configurationSourceMaps);
+        if (targetDefaultsResults.length > 0) {
+            mergeCreateNodesResultsFromSinglePlugin(targetDefaultsResults, mergeToManager, nodesManager, externalNodes, errors);
         }
     }
-    // The intermediate apply may have rebuilt dependsOn / inputs arrays
-    // via spread merges, leaving sentinels inserted against the
-    // intermediate rootMap pointing at now-orphaned arrays. Re-walking
-    // the final merged targets rebinds each encountered sentinel's
-    // `parent` to the current array (see
-    // ProjectNameInNodePropsManager#processInputs / processDependsOn).
-    nodesManager.registerNameRefs(intermediateDefaultRootMap);
-    // Overlay default-plugin attribution onto the main source maps using
-    // "only fill missing" semantics. Any key already present in
-    // configurationSourceMaps was written by a specified plugin or by
-    // target defaults, and that attribution is strictly more correct:
-    //  - For fields the default plugin never shadowed, the existing entry
-    //    already matches what the default plugin would overlay.
-    //  - For fields where a default plugin placed `...` after other keys,
-    //    those keys yielded to the base during the single-layer apply
-    //    above. The stale default-plugin entry in
-    //    `defaultConfigurationSourceMaps` must NOT clobber the base
-    //    attribution that the specified plugin / TD already recorded.
-    const mainRootMap = nodesManager.getRootMap();
-    for (const root in defaultConfigurationSourceMaps) {
-        const existing = (configurationSourceMaps[root] ??= {});
-        const incoming = defaultConfigurationSourceMaps[root];
-        // A default plugin's targets are synthesized into the main rootmap by
-        // target defaults *before* the default layer is applied, so target
-        // defaults wrote the main source map's entry for the target node and its
-        // identity fields first — even though it never authored them (it only
-        // stamps them as a merge guard and cannot bring a target into existence).
-        // The identity fields are the executor/command plus, for run-commands, the
-        // `options.command`/`options.commands` the synthetic copies from the winner
-        // to stay compatible (#36067). For those keys, the real default plugin's
-        // attribution must override the target-defaults stamp.
-        const identityKeys = new Set();
-        for (const targetName in mainRootMap[root]?.targets ?? {}) {
-            const base = (0, source_maps_1.targetSourceMapKey)(targetName);
-            identityKeys.add(base);
-            identityKeys.add(`${base}.executor`);
-            identityKeys.add(`${base}.command`);
-            identityKeys.add(`${base}.options.command`);
-            identityKeys.add(`${base}.options.commands`);
-        }
-        for (const key in incoming) {
-            if (existing[key] === undefined) {
-                existing[key] = incoming[key];
-            }
-            else if (identityKeys.has(key) &&
-                existing[key][1] === source_maps_1.TARGET_DEFAULTS_PLUGIN_NAME) {
-                existing[key] = incoming[key];
-            }
-        }
+    // Merge the default plugins into the manager on top of the specified + TD
+    // base, from their original results. This is the same source-map-aware path
+    // the other layers take, so every field a default plugin wins — including
+    // fields it overrides on a specified/TD target — is attributed to it by the
+    // merge itself, `'...'` spreads resolve against the real base (keys a spread
+    // lets the base win keep their base attribution), and identity provenance
+    // follows the node-ownership rules in `recordTargetIdentitySourceMapInfo` /
+    // `getMergeValueResult`.
+    for (const pluginResults of defaultResults) {
+        mergeCreateNodesResultsFromSinglePlugin(pluginResults, mergeToManager, nodesManager, externalNodes, errors);
     }
     const projectRootMap = nodesManager.getRootMap();
     try {

package/dist/src/tasks-runner/life-cycles/performance-analysis.d.ts

@@ -29,15 +29,20 @@ export interface Timespan {
     /** `parallelism: false` tasks running during the slice (each one holds every slot). */
     nonParallel: number;
 }
+/**
+ * A task and how long it ran (ms). The unit the report's task lists are built from —
+ * shared with the renderers so the producer and the formatters can't drift.
+ */
+export interface TaskDurationRow {
+    id: string;
+    duration: number;
+}
 export interface PerformanceSummary {
     runDuration: number;
     criticalPathDuration: number;
     criticalPathTaskCount: number;
     /** Longest critical-path tasks that ran (desc, capped at a few), cache hits excluded; empty when the path was fully cached. */
-    criticalPathTop: Array<{
-        id: string;
-        duration: number;
-    }>;
+    criticalPathTop: TaskDurationRow[];
     /** Ids of tasks that failed (slowest first), for the GitHub Actions summary's failed-tasks list. Continuous tasks and tasks without a complete window are excluded. */
     failedTasks: string[];
     /** runDuration − criticalPathDuration. */
@@ -60,6 +65,8 @@ export interface PerformanceSummary {
     cacheableCount: number;
     cacheSkipped: boolean;
     remoteCacheEnabled: boolean;
+    /** The workspace opted out of Nx Cloud (`neverConnectToCloud` / NX_NO_CLOUD) — never recommend it. */
+    cloudOptedOut: boolean;
 }
 /** Construction-time inputs for {@link PerformanceLifeCycle}. */
 export interface PerformanceLifeCycleOptions {

package/dist/src/tasks-runner/life-cycles/performance-analysis.js

@@ -18,6 +18,8 @@ const CACHE_HIT_STATUSES = new Set([
 ]);
 /** Gap (ms) still counted as the same pre-dispatch hashing phase; a larger gap means older, unrelated hashing (e.g. a daemon's previous run). */
 const PRE_DISPATCH_HASH_GAP = 1000;
+/** A critical-path task shorter than this fraction of the path is noise, not a speed-up target. */
+const CRITICAL_PATH_TOP_MIN_FRACTION = 0.2;
 /**
  * Pure analysis over one finished run's collected timings — no lifecycle state and no
  * mutation. Built once per run from the {@link PerformanceLifeCycle}'s accumulated
@@ -171,15 +173,17 @@ class PerformanceAnalysis {
      * (their duration is just restore time); no-status tasks (synthetic test runs) are
      * kept.
      */
-    computeCriticalPathTop(criticalPathTasks, durations) {
-        return criticalPathTasks
+    computeCriticalPathTop(criticalPathTasks, durations, criticalPathDuration) {
+        return (criticalPathTasks
             .filter((id) => {
             const status = this.statuses.get(id);
             return !status || !CACHE_HIT_STATUSES.has(status);
         })
             .map((id) => ({ id, duration: durations.get(id) ?? 0 }))
+            // Only tasks that meaningfully shape the path are worth speeding up.
+            .filter((t) => t.duration >= CRITICAL_PATH_TOP_MIN_FRACTION * criticalPathDuration)
             .sort((a, b) => b.duration - a.duration)
-            .slice(0, 3);
+            .slice(0, 3));
     }
     /** Cache outcome: tasks restored (`cacheHits`) and the total with a cache outcome (`cacheableCount` = hits + ran). No-status tasks count for neither. */
     computeCacheStats() {
@@ -244,12 +248,15 @@ class PerformanceAnalysis {
             cores,
             criticalPathDuration,
         });
-        const criticalPathTop = this.computeCriticalPathTop(criticalPathTasks, durations);
+        const criticalPathTop = this.computeCriticalPathTop(criticalPathTasks, durations, criticalPathDuration);
         const { cacheHits, cacheableCount } = this.computeCacheStats();
         // `skipNxCache` already folds in NX_SKIP_NX_CACHE / NX_DISABLE_NX_CACHE
         // (normalized in command-line-utils) — don't re-read those env vars here.
         const cacheSkipped = this.options.skipNxCache === true;
         const remoteCacheEnabled = this.remoteCacheEnabled();
+        const cloudOptedOut = this.options.nxJson
+            ? !!(0, nx_cloud_utils_1.isNxCloudDisabled)(this.options.nxJson)
+            : false;
         // Coordinator-dominated: hashing/scheduling outweighs task work by >3x the
         // critical path, which keeps cold runs critical-path-bound.
         const coordinatorDominated = coordinatorOverhead >= performance_report_1.MEANINGFUL_OVERHEAD &&
@@ -271,14 +278,16 @@ class PerformanceAnalysis {
             parallel,
             cores,
             isCI,
-            // Can only start distributing in CI when not already doing so.
-            canDistribute: isCI && !distributing,
+            // Can only start distributing in CI when not already doing so — and never
+            // suggest Nx Agents to a workspace that opted out of Nx Cloud.
+            canDistribute: isCI && !distributing && !cloudOptedOut,
             distributing,
             coordinatorDominated,
             cacheHits,
             cacheableCount,
             cacheSkipped,
             remoteCacheEnabled,
+            cloudOptedOut,
         };
     }
 }

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

@@ -142,8 +142,9 @@ function flushPerformanceReport() {
         // restore_terminal cooks the terminal back post-TUI, so console.log's plain \n
         // renders fine; it also supplies the single trailing newline formatReport omits.
         console.log((0, performance_report_1.formatReport)(summary));
-        // In GitHub Actions, also append the report (plus a per-task table) to the job
-        // summary page. Independent of the console.log above so neither masks the other.
+        // In GitHub Actions, also append the report to the job summary page — the same stats
+        // as above, led by the run's outcome (a failed-tasks list, or a success line).
+        // Independent of the console.log above so neither masks the other.
         writePerformanceReportToGitHubActions(summary);
     }
     catch (e) {
@@ -157,8 +158,8 @@ function flushPerformanceReport() {
 /**
  * Append the performance report to the GitHub Actions job summary page when running in
  * Actions (`$GITHUB_STEP_SUMMARY` is set there and nowhere else). No-op otherwise. The
- * per-task table is computed lazily so non-CI runs don't pay for it. Best-effort: a
- * write failure must never affect the run.
+ * Markdown is rendered below the guard, so non-CI runs don't pay to format a report
+ * nothing reads. Best-effort: a write failure must never affect the run.
  *
  * Skipped for a nested run (one nx command invoked by another nx task's command), so only
  * the outermost run writes to the summary. Nx sets `NX_TASK_TARGET_PROJECT` on every task's

package/dist/src/tasks-runner/life-cycles/performance-report.d.ts

@@ -1,12 +1,16 @@
 import type { PerformanceSummaryPayload } from '../../native';
-import type { PerformanceSummary } from './performance-analysis';
+import type { PerformanceSummary, TaskDurationRow } from './performance-analysis';
 /**
- * A recommendation built from structured parts so the link text comes from the
- * link definition (not a substring scanned out of the assembled report). A part
- * is either literal text or a {@link RecLink}; the renderers below project the
- * same parts to the terminal string, the payload string, and the popup links.
+ * A recommendation built from structured parts so the link text comes from the link
+ * definition (not a substring scanned out of the assembled report). A part is literal
+ * text, a {@link RecLink}, or a {@link RecTaskRows}, projected to each output string by
+ * {@link renderRecommendation}.
+ *
+ * String parts must be single-line — multi-line content needs its own structured part (as
+ * {@link RecTaskRows} is). TS can't enforce this: `string` is already a handled member, so
+ * a multi-line one compiles and then breaks the Markdown nested list.
  */
-type RecPart = string | RecLink;
+type RecPart = string | RecLink | RecTaskRows;
 export type Recommendation = RecPart[];
 /**
  * A docs link inside a recommendation: a sentence is the visible text and the whole of
@@ -15,16 +19,22 @@ export type Recommendation = RecPart[];
  * re-links the phrase from {@link PerformanceSummaryPayload.links}.
  */
 interface RecLink {
-    /** Visible label: the sentence that links. */
     visible: string;
-    /** OSC 8 click target / appended URL: the utm-tagged URL. */
     href: string;
 }
+/**
+ * The critical path's longest tasks as data, so each renderer formats them natively:
+ * the terminal and payload as space-aligned columns, Markdown as a nested list
+ * (HTML collapses space runs, so aligned columns don't survive rendering there).
+ */
+type RecTaskRows = TaskDurationRow[];
 /**
  * The recommendation string the napi payload ships and the Rust popup matches against.
  * Links are URL-less (the popup re-links them from {@link PerformanceSummaryPayload.links}).
  */
 export declare function recommendationToPayloadString(rec: Recommendation): string;
+/** Below this run duration (ms), the run is already fast — recommend nothing. */
+export declare const MIN_RECOMMENDATION_RUN_DURATION = 30000;
 /** Below this (ms) overhead is noise, not worth a recommendation. */
 export declare const MEANINGFUL_OVERHEAD = 1000;
 /**

package/dist/src/tasks-runner/life-cycles/performance-report.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MEANINGFUL_OVERHEAD = void 0;
+exports.MEANINGFUL_OVERHEAD = exports.MIN_RECOMMENDATION_RUN_DURATION = void 0;
 exports.recommendationToPayloadString = recommendationToPayloadString;
 exports.buildRecommendations = buildRecommendations;
 exports.formatReport = formatReport;
@@ -25,15 +25,49 @@ const NX_DISTRIBUTE_CTA = 'Distribute across machines with Nx Agents';
 function phraseLink(phrase, taggedUrl) {
     return { visible: phrase, href: taggedUrl };
 }
+// Discriminate positively — test for what each part *is*. A `!isRecTaskRows` catch-all
+// would misclassify a future `RecPart` member as a link; TS can't catch that (it never
+// checks a predicate body), so `recommendationLinks`' `.filter(isRecLink)` would ship
+// `{text: undefined, href: undefined}` to the popup.
 function isRecLink(part) {
-    return typeof part !== 'string';
+    return typeof part !== 'string' && 'href' in part;
+}
+function isRecTaskRows(part) {
+    return Array.isArray(part);
+}
+/**
+ * Project a recommendation to a string, formatting each non-text part with the caller's
+ * renderers. The three output targets (payload, terminal, Markdown) share this one dispatch.
+ * After the string and task-rows branches a part is a {@link RecLink}, so `render.link`
+ * takes it directly — and a new {@link RecPart} member that is neither would fail to satisfy
+ * that `RecLink` parameter, turning "forgot to handle it" into a compile error right here.
+ */
+function renderRecommendation(rec, render) {
+    return rec
+        .map((part) => {
+        if (typeof part === 'string') {
+            return part;
+        }
+        if (isRecTaskRows(part)) {
+            return render.taskRows(part);
+        }
+        return render.link(part);
+    })
+        .join('');
 }
 /**
  * The recommendation string the napi payload ships and the Rust popup matches against.
  * Links are URL-less (the popup re-links them from {@link PerformanceSummaryPayload.links}).
  */
 function recommendationToPayloadString(rec) {
-    return rec.map((part) => (!isRecLink(part) ? part : part.visible)).join('');
+    return renderRecommendation(rec, {
+        link: (link) => link.visible,
+        taskRows: taskRowsToText,
+    });
+}
+/** Task rows as the text block the terminal and payload embed: newline-led, space-aligned columns. */
+function taskRowsToText(tasks) {
+    return ['', ...formatTopTaskRows(tasks)].join('\n');
 }
 /**
  * The recommendation as a terminal string. With OSC 8 the phrase becomes a hyperlink
@@ -42,16 +76,12 @@ function recommendationToPayloadString(rec) {
  * are off.
  */
 function recommendationToTerminalString(rec, hyperlinks) {
-    return rec
-        .map((part) => {
-        if (!isRecLink(part)) {
-            return part;
-        }
-        return hyperlinks
-            ? (0, terminal_link_1.terminalLink)(part.visible, part.href)
-            : `${part.visible} → ${part.href}`;
-    })
-        .join('');
+    return renderRecommendation(rec, {
+        link: (link) => hyperlinks
+            ? (0, terminal_link_1.terminalLink)(link.visible, link.href)
+            : `${link.visible} → ${link.href}`,
+        taskRows: taskRowsToText,
+    });
 }
 /** The popup links (phrase + href) for every link in a recommendation list, for OSC 8 re-linking. */
 function recommendationLinks(recommendations) {
@@ -59,6 +89,8 @@ function recommendationLinks(recommendations) {
         .filter(isRecLink)
         .map((part) => ({ text: part.visible, href: part.href })));
 }
+/** Below this run duration (ms), the run is already fast — recommend nothing. */
+exports.MIN_RECOMMENDATION_RUN_DURATION = 30_000;
 /** At/below this hit rate, recommend remote cache (if off); above it caching works. */
 const LOW_CACHE_HIT_RATE = 0.1;
 /** Below this (ms) overhead is noise, not worth a recommendation. */
@@ -75,7 +107,8 @@ function recoverableTime(s) {
 }
 /** Render the longest critical-path tasks as aligned columns: task (left), duration (right). */
 function formatTopTaskRows(tasks) {
-    // The only caller returns early when empty, so `tasks` is non-empty here.
+    // Non-empty by construction: the only recommendation carrying task rows requires
+    // `criticalPathTop.length > 0` to apply, so no empty array reaches the widths below.
     const idWidth = Math.max(...tasks.map((t) => t.id.length));
     const durations = tasks.map((t) => (0, native_1.formatDuration)(t.duration));
     const durWidth = Math.max(...durations.map((d) => d.length));
@@ -136,8 +169,10 @@ const RECOMMENDATIONS = [
     },
     {
         // Barely-used cache with no remote: set up Nx Cloud. Whole-phrase link; the payload
-        // string stays URL-less (the popup re-links the phrase).
+        // string stays URL-less (the popup re-links the phrase). Never pushed at a
+        // workspace that opted out of Nx Cloud.
         isApplicable: (c) => !c.cacheSkipped &&
+            !c.cloudOptedOut &&
             c.cacheableCount > 0 &&
             !c.remoteCacheEnabled &&
             c.cacheHits / c.cacheableCount <= LOW_CACHE_HIT_RATE,
@@ -168,10 +203,8 @@ const RECOMMENDATIONS = [
         // only multi-line rec). Nothing ran (fully cached) → it doesn't apply.
         isApplicable: (c) => criticalPathBound(c) && c.criticalPathTop.length > 0,
         build: (c) => [
-            [
-                `Speed up or split the longest tasks on the critical path:`,
-                ...formatTopTaskRows(c.criticalPathTop),
-            ].join('\n'),
+            `Speed up or split the longest tasks on the critical path:`,
+            c.criticalPathTop,
         ],
     },
 ];
@@ -181,6 +214,10 @@ const RECOMMENDATIONS = [
  * the GitHub-summary Markdown, and the TUI payload.
  */
 function buildRecommendations(s) {
+    // A fast run has nothing worth optimizing — stats only, no advice.
+    if (s.runDuration < exports.MIN_RECOMMENDATION_RUN_DURATION) {
+        return [];
+    }
     const c = {
         recoverableByParallel: s.recoverableByParallel,
         recoverableByMachines: s.recoverableByMachines,
@@ -194,6 +231,7 @@ function buildRecommendations(s) {
         cacheableCount: s.cacheableCount,
         cacheSkipped: s.cacheSkipped,
         remoteCacheEnabled: s.remoteCacheEnabled,
+        cloudOptedOut: s.cloudOptedOut,
     };
     return RECOMMENDATIONS.filter((r) => r.isApplicable(c)).map((r) => r.build(c));
 }
@@ -252,18 +290,17 @@ function formatReport(s) {
 }
 /**
  * A recommendation as Markdown: every link becomes `[phrase](href)` (no OSC 8, unlike the
- * terminal renderer) — the whole sentence reads as prose and is the link text. The
- * critical-path rec embeds newline-separated, space-aligned task rows; collapse them to
- * `<br>`-joined lines so they render inside the list item.
+ * terminal renderer) — the whole sentence reads as prose and is the link text. Task rows
+ * become a nested list under the recommendation's bullet (space-aligned columns don't
+ * survive HTML's whitespace collapsing).
  */
 function recommendationToMarkdownString(rec) {
-    return rec
-        .map((part) => !isRecLink(part) ? part : `[${part.visible}](${part.href})`)
-        .join('')
-        .split('\n')
-        .map((line) => line.trim())
-        .filter(Boolean)
-        .join('<br>');
+    return renderRecommendation(rec, {
+        link: (link) => `[${link.visible}](${link.href})`,
+        taskRows: (rows) => rows
+            .map((t) => `\n  - \`${t.id}\` — ${(0, native_1.formatDuration)(t.duration)}`)
+            .join(''),
+    });
 }
 /**
  * The performance report as GitHub-flavored Markdown for the Actions job summary

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

@@ -25,6 +25,7 @@ const update_manager_1 = require("../nx-cloud/update-manager");
 const logger_1 = require("../utils/logger");
 const nx_key_1 = require("../utils/nx-key");
 const output_1 = require("../utils/output");
+const configure_ai_agents_disclaimer_1 = require("../ai/configure-ai-agents-disclaimer");
 const sync_generators_1 = require("../utils/sync-generators");
 const workspace_root_1 = require("../utils/workspace-root");
 const create_task_graph_1 = require("./create-task-graph");
@@ -410,9 +411,10 @@ async function printConfigureAiAgentsDisclaimer() {
             return;
         }
         const { outdatedAgents } = await client_1.daemonClient.getConfigureAiAgentsStatus();
-        if (outdatedAgents.length > 0) {
-            output_1.output.logRawLine(output_1.output.dim('Your AI agent configuration is outdated. Run "nx configure-ai-agents" to update.'));
+        if (!(0, configure_ai_agents_disclaimer_1.shouldPrintConfigureAiAgentsDisclaimer)(outdatedAgents, workspace_root_1.workspaceRoot)) {
+            return;
         }
+        output_1.output.logRawLine(output_1.output.dim('Your AI agent configuration is outdated. Run "nx configure-ai-agents" to update.'));
     }
     catch {
         // Silently ignore errors

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

@@ -1,5 +1,14 @@
 import { ProjectGraph } from '../config/project-graph';
 import { Task } from '../config/task-graph';
+/**
+ * Resolves the FORCE_COLOR value for forked child processes.
+ *
+ * When the user sets FORCE_COLOR=0, bin/nx.ts deletes it from process.env
+ * (workaround for picocolors treating "0" as truthy) and saves the original
+ * value in NX_ORIGINAL_FORCE_COLOR. Without this check, the undefined
+ * FORCE_COLOR would default to 'true', re-enabling colors in all children.
+ */
+export declare function getForceColorForChild(): string;
 export declare function getEnvVariablesForBatchProcess(skipNxCache: boolean, captureStderr: boolean): NodeJS.ProcessEnv;
 export declare function getTaskSpecificEnv(task: Task, graph: ProjectGraph): NodeJS.ProcessEnv;
 export declare function getEnvVariablesForTask(task: Task, taskSpecificEnv: NodeJS.ProcessEnv, forceColor: string, skipNxCache: boolean, captureStderr: boolean, outputPath: string, streamOutput: boolean): NodeJS.ProcessEnv;