nx 23.2.0-beta.0 → 23.2.0-beta.10

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. */

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,28 @@
 import type { PerformanceSummaryPayload } from '../../native';
-import type { PerformanceSummary } from './performance-analysis';
+import type { NxJsonConfiguration } from '../../config/nx-json';
+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.
+ * Point the remote-cache CTA at a short Nx Cloud onboarding URL for a
+ * disconnected GitHub workspace - the VCS flow where Cloud opens the nx.json PR.
+ * Non-GitHub remotes keep the get-started link (handles every provider) and skip
+ * the network entirely. Runs in CI too - terminal + job summary.
+ *
+ * Best-effort: the get-started link stays on failure/timeout. Fired at run start;
+ * the CTA needs a >30s run (MIN_RECOMMENDATION_RUN_DURATION), so the fetch
+ * always resolves first.
+ */
+export declare function prefetchRemoteCacheOnboardingUrl(nxJson: NxJsonConfiguration): Promise<void>;
+/**
+ * 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,11 +31,15 @@ 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}).

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

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MEANINGFUL_OVERHEAD = exports.MIN_RECOMMENDATION_RUN_DURATION = void 0;
+exports.prefetchRemoteCacheOnboardingUrl = prefetchRemoteCacheOnboardingUrl;
 exports.recommendationToPayloadString = recommendationToPayloadString;
 exports.buildRecommendations = buildRecommendations;
 exports.formatReport = formatReport;
@@ -8,14 +9,72 @@ exports.formatReportMarkdown = formatReportMarkdown;
 exports.buildExitSummaryPayload = buildExitSummaryPayload;
 const native_1 = require("../../native");
 const terminal_link_1 = require("../../utils/terminal-link");
+const nx_cloud_utils_1 = require("../../utils/nx-cloud-utils");
+const url_shorten_1 = require("../../nx-cloud/utilities/url-shorten");
+const get_cloud_options_1 = require("../../nx-cloud/utilities/get-cloud-options");
+const git_utils_1 = require("../../utils/git-utils");
+const logger_1 = require("../../utils/logger");
 const NX_AGENTS_URL = 'https://nx.dev/ci/features/distribute-task-execution';
-const NX_REMOTE_CACHE_URL = 'https://nx.dev/ci/features/remote-cache';
+// Fallback for the remote-cache CTA when the short onboarding URL can't be
+// fetched: the generic Cloud get-started page (still drives to onboarding).
+const NX_CLOUD_GET_STARTED_URL = 'https://cloud.nx.app/get-started';
 const NX_PERFORMANCE_URL = 'https://nx.dev/docs/concepts/ci-concepts/parallelization-distribution';
 /** utm tag attributing report clicks back to it; the content names the CTA clicked. */
 const utm = (content) => `?utm_source=nx-cli&utm_medium=cli&utm_campaign=performance-report&utm_content=${content}`;
 const NX_PERFORMANCE_LINK = `${NX_PERFORMANCE_URL}${utm('parallelization')}`;
 const NX_AGENTS_LINK = `${NX_AGENTS_URL}${utm('nx-agents')}`;
-const NX_REMOTE_CACHE_LINK = `${NX_REMOTE_CACHE_URL}${utm('remote-cache')}`;
+const NX_REMOTE_CACHE_LINK = `${NX_CLOUD_GET_STARTED_URL}${utm('remote-cache')}`;
+// Defaults to the get-started link; a disconnected workspace gets a short Nx
+// Cloud onboarding URL instead (see prefetchRemoteCacheOnboardingUrl).
+let remoteCacheLink = NX_REMOTE_CACHE_LINK;
+// Give up on the short URL after this long so a slow/hung Cloud API never
+// lingers past the exit report. Covers two sequential round trips (features
+// GET, onboarding POST); the 30s CTA floor leaves room. Timing out also aborts
+// the request - Promise.race alone would leave the socket holding the event
+// loop open, which strands programmatic callers that never process.exit.
+const ONBOARDING_URL_TIMEOUT = 5000;
+/**
+ * Point the remote-cache CTA at a short Nx Cloud onboarding URL for a
+ * disconnected GitHub workspace - the VCS flow where Cloud opens the nx.json PR.
+ * Non-GitHub remotes keep the get-started link (handles every provider) and skip
+ * the network entirely. Runs in CI too - terminal + job summary.
+ *
+ * Best-effort: the get-started link stays on failure/timeout. Fired at run start;
+ * the CTA needs a >30s run (MIN_RECOMMENDATION_RUN_DURATION), so the fetch
+ * always resolves first.
+ */
+async function prefetchRemoteCacheOnboardingUrl(nxJson) {
+    if ((0, nx_cloud_utils_1.isNxCloudDisabled)(nxJson) || (0, nx_cloud_utils_1.isNxCloudUsed)(nxJson)) {
+        return;
+    }
+    if ((0, git_utils_1.getVcsRemoteInfo)()?.domain !== 'github.com') {
+        return;
+    }
+    const abortController = new AbortController();
+    try {
+        const url = await Promise.race([
+            (0, url_shorten_1.createNxCloudOnboardingURL)('nx-cli-perf-report', undefined, undefined, false, false, undefined, abortController.signal),
+            new Promise((resolve) => {
+                // unref so the pending timer never keeps the CLI alive on its own.
+                setTimeout(() => {
+                    abortController.abort();
+                    resolve(null);
+                }, ONBOARDING_URL_TIMEOUT).unref();
+            }),
+        ]);
+        // createNxCloudOnboardingURL never throws - on an unreachable API it returns a
+        // paste-a-token URL (accessToken=undefined). Only accept a real short link.
+        if (url?.startsWith(`${(0, get_cloud_options_1.getCloudUrl)()}/connect/`)) {
+            remoteCacheLink = url;
+        }
+        else {
+            logger_1.logger.verbose(`Keeping the get-started remote-cache link (${url === null ? 'onboarding URL timed out' : `got: ${url}`})`);
+        }
+    }
+    catch (e) {
+        logger_1.logger.verbose(`Keeping the get-started remote-cache link: ${e}`);
+    }
+}
 /**
  * Whole-phrase CTA: the whole sentence is the link. The Rust TUI popup keeps no
  * copy of this string; it gets the phrase + href from the exit payload's `links`.
@@ -25,15 +84,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 +135,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) {
@@ -77,7 +166,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));
@@ -145,7 +235,7 @@ const RECOMMENDATIONS = [
             c.cacheableCount > 0 &&
             !c.remoteCacheEnabled &&
             c.cacheHits / c.cacheableCount <= LOW_CACHE_HIT_RATE,
-        build: () => [phraseLink(NX_REMOTE_CACHE_CTA, NX_REMOTE_CACHE_LINK), `.`],
+        build: () => [phraseLink(NX_REMOTE_CACHE_CTA, remoteCacheLink), `.`],
     },
     {
         // Cache skipped: drop the flag to restore unchanged tasks instantly.
@@ -172,10 +262,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,
         ],
     },
 ];
@@ -261,18 +349,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/life-cycles/static-run-many-terminal-output-life-cycle.d.ts

@@ -16,14 +16,39 @@ export declare class StaticRunManyTerminalOutputLifeCycle implements LifeCycle {
     private readonly taskOverrides;
     failedTasks: Task[];
     cachedTasks: Task[];
+    stoppedTasks: Task[];
     allCompletedTasks: Map<string, Task>;
+    private collapsedTasks;
+    /** Stopped tasks that produced output; a batch-stopped task has none. */
+    private stoppedTasksWithOutput;
     constructor(projectNames: string[], tasks: Task[], args: {
         targets?: string[];
         configuration?: string;
+        verbose?: boolean;
+        outputStyle?: string;
     }, taskOverrides: any);
     startCommand(): void;
     endCommand(): void;
+    /**
+     * Tasks with a `skipped` status are never reported through `endTasks`, so
+     * they are derived by subtracting everything that did complete.
+     */
     private skippedTasks;
+    /**
+     * Whether this run prints every task's output in full rather than collapsing
+     * the ones that succeeded.
+     */
+    private get printsFullOutput();
+    /**
+     * Tells the reader that output was withheld, so a task that succeeded while
+     * printing something worth reading is not silently swallowed.
+     */
+    private hiddenOutputHint;
+    /**
+     * Tasks that never produced output worth printing are summarized as counts,
+     * with their names available behind --verbose.
+     */
+    private tasksNotRunSummary;
     endTasks(taskResults: TaskResult[]): void;
-    printTaskTerminalOutput(task: Task, cacheStatus: TaskStatus, terminalOutput: string): void;
+    printTaskTerminalOutput(task: Task, taskStatus: TaskStatus, terminalOutput: string): void;
 }

package/dist/src/tasks-runner/life-cycles/static-run-many-terminal-output-life-cycle.js

@@ -20,7 +20,11 @@ class StaticRunManyTerminalOutputLifeCycle {
         this.taskOverrides = taskOverrides;
         this.failedTasks = [];
         this.cachedTasks = [];
+        this.stoppedTasks = [];
         this.allCompletedTasks = new Map();
+        this.collapsedTasks = 0;
+        /** Stopped tasks that produced output; a batch-stopped task has none. */
+        this.stoppedTasksWithOutput = 0;
     }
     startCommand() {
         if (this.tasks.length === 0) {
@@ -55,13 +59,18 @@ class StaticRunManyTerminalOutputLifeCycle {
             output_1.output.logSingleLine(`No tasks were run`);
             return;
         }
-        if (this.failedTasks.length === 0) {
+        // A stopped task was killed mid-flight, so the run did not complete even
+        // though nothing outright failed. `didCommandComplete` already treats it
+        // that way; reporting "Successfully ran" here would contradict it.
+        if (this.failedTasks.length === 0 && this.stoppedTasks.length === 0) {
             output_1.output.addVerticalSeparatorWithoutNewLines('green');
             const bodyLines = this.cachedTasks.length > 0
                 ? [
                     output_1.output.dim(`Nx read the output from the cache instead of running the command for ${this.cachedTasks.length} out of ${this.tasks.length} tasks.`),
                 ]
                 : [];
+            bodyLines.push(...this.tasksNotRunSummary());
+            bodyLines.push(...this.hiddenOutputHint());
             output_1.output.success({
                 title: `Successfully ran ${(0, formatting_utils_1.formatTargetsAndProjects)(this.projectNames, this.args.targets, this.tasks)}`,
                 bodyLines,
@@ -74,22 +83,95 @@ class StaticRunManyTerminalOutputLifeCycle {
             if (skippedTasks.length > 0) {
                 bodyLines.push(output_1.output.dim('Tasks not run because their dependencies failed or --nx-bail=true:'), '', ...skippedTasks.map((task) => `${output_1.output.dim('-')} ${task.id}`), '');
             }
-            bodyLines.push(output_1.output.dim('Failed tasks:'), '', ...[...this.failedTasks.values()].map((task) => `${output_1.output.dim('-')} ${task.id}`));
+            if (this.stoppedTasks.length > 0) {
+                bodyLines.push(output_1.output.dim('Tasks stopped before they finished:'), '', ...this.stoppedTasks.map((task) => `${output_1.output.dim('-')} ${task.id}`), '');
+            }
+            if (this.failedTasks.length > 0) {
+                bodyLines.push(output_1.output.dim('Failed tasks:'), '', ...[...this.failedTasks.values()].map((task) => `${output_1.output.dim('-')} ${task.id}`));
+            }
+            bodyLines.push(...this.hiddenOutputHint());
+            const targets = (0, formatting_utils_1.formatTargetsAndProjects)(this.projectNames, this.args.targets, this.tasks);
             output_1.output.error({
-                title: `Running ${(0, formatting_utils_1.formatTargetsAndProjects)(this.projectNames, this.args.targets, this.tasks)} failed`,
+                title: this.failedTasks.length > 0
+                    ? `Running ${targets} failed`
+                    : `Running ${targets} did not complete`,
                 bodyLines,
             });
         }
     }
+    /**
+     * Tasks with a `skipped` status are never reported through `endTasks`, so
+     * they are derived by subtracting everything that did complete.
+     */
     skippedTasks() {
         return this.tasks.filter((t) => !this.allCompletedTasks.has(t.id));
     }
+    /**
+     * Whether this run prints every task's output in full rather than collapsing
+     * the ones that succeeded.
+     */
+    get printsFullOutput() {
+        return (0, output_1.printsFullTaskOutput)(this.args);
+    }
+    /**
+     * Tells the reader that output was withheld, so a task that succeeded while
+     * printing something worth reading is not silently swallowed.
+     */
+    hiddenOutputHint() {
+        const withheld = [];
+        if (this.collapsedTasks > 0) {
+            withheld.push(`${this.collapsedTasks} successful ${this.collapsedTasks === 1 ? 'task' : 'tasks'}`);
+        }
+        // A stopped task's partial output is what diagnoses a hang, and it is
+        // dropped by default, so say so even when nothing collapsed.
+        if (this.stoppedTasksWithOutput > 0) {
+            withheld.push(`${this.stoppedTasksWithOutput} stopped ${this.stoppedTasksWithOutput === 1 ? 'task' : 'tasks'}`);
+        }
+        if (this.printsFullOutput || withheld.length === 0) {
+            return [];
+        }
+        const total = this.collapsedTasks + this.stoppedTasksWithOutput;
+        return [
+            '',
+            `${output_1.output.dim(`Output of ${withheld.join(' and ')} ${total === 1 && withheld.length === 1 ? 'was' : 'were'} not shown. Run with`)} --verbose ${output_1.output.dim('or')} --output-style=static ${output_1.output.dim('to see it.')}`,
+        ];
+    }
+    /**
+     * Tasks that never produced output worth printing are summarized as counts,
+     * with their names available behind --verbose.
+     */
+    tasksNotRunSummary() {
+        const skippedTasks = this.skippedTasks();
+        const counts = [];
+        if (skippedTasks.length > 0) {
+            counts.push(`${skippedTasks.length} skipped`);
+        }
+        if (this.stoppedTasks.length > 0) {
+            counts.push(`${this.stoppedTasks.length} stopped`);
+        }
+        if (counts.length === 0) {
+            return [];
+        }
+        const lines = [output_1.output.dim(counts.join(', '))];
+        if (this.printsFullOutput) {
+            lines.push('', ...[...skippedTasks, ...this.stoppedTasks].map((task) => `${output_1.output.dim('-')} ${task.id}`));
+        }
+        return lines;
+    }
     endTasks(taskResults) {
         for (let t of taskResults) {
             this.allCompletedTasks.set(t.task.id, t.task);
             if (t.status === 'failure') {
                 this.failedTasks.push(t.task);
             }
+            else if (t.status === 'stopped') {
+                this.stoppedTasks.push(t.task);
+                // A batch-stopped task is reported with no output at all, so counting
+                // it would have the hint promise something --verbose cannot show.
+                if (t.terminalOutput) {
+                    this.stoppedTasksWithOutput++;
+                }
+            }
             else if (t.status === 'local-cache') {
                 this.cachedTasks.push(t.task);
             }
@@ -101,9 +183,21 @@ class StaticRunManyTerminalOutputLifeCycle {
             }
         }
     }
-    printTaskTerminalOutput(task, cacheStatus, terminalOutput) {
+    printTaskTerminalOutput(task, taskStatus, terminalOutput) {
         const args = (0, utils_1.getPrintableCommandArgsForTask)(task);
-        output_1.output.logCommandOutput(args.join(' '), cacheStatus, terminalOutput);
+        if (this.printsFullOutput || taskStatus === 'failure') {
+            // A stopped task was killed part way through; under --verbose or
+            // --output-style=static its partial output is shown, which is what
+            // diagnoses a hang. It is dropped on the default path below.
+            output_1.output.logCommandOutput(args.join(' '), taskStatus, terminalOutput);
+            return;
+        }
+        // Named in the end of run summary instead; output not shown by default.
+        if (taskStatus === 'skipped' || taskStatus === 'stopped') {
+            return;
+        }
+        this.collapsedTasks++;
+        output_1.output.logCommandSummary(args.join(' '), taskStatus);
     }
 }
 exports.StaticRunManyTerminalOutputLifeCycle = StaticRunManyTerminalOutputLifeCycle;

package/dist/src/tasks-runner/life-cycles/static-run-one-terminal-output-life-cycle.d.ts

@@ -16,13 +16,39 @@ export declare class StaticRunOneTerminalOutputLifeCycle implements LifeCycle {
     private readonly args;
     failedTasks: Task[];
     cachedTasks: Task[];
+    stoppedTasks: Task[];
+    allCompletedTasks: Map<string, Task>;
+    private collapsedTasks;
+    /** Stopped tasks that produced output; a batch-stopped task has none. */
+    private stoppedTasksWithOutput;
     constructor(initiatingProject: string, projectNames: string[], tasks: Task[], args: {
         targets?: string[];
         configuration?: string;
         verbose?: boolean;
+        outputStyle?: string;
     });
+    /**
+     * Whether this run prints every task's output in full rather than collapsing
+     * the ones that succeeded.
+     */
+    private get printsFullOutput();
+    /**
+     * Tells the reader that output was withheld, so a task that succeeded while
+     * printing something worth reading is not silently swallowed.
+     */
+    private hiddenOutputHint;
     startCommand(): void;
     endCommand(): void;
+    /**
+     * Tasks with a `skipped` status are never reported through `endTasks`, so
+     * they are derived by subtracting everything that did complete.
+     */
+    private skippedTasks;
+    /**
+     * Tasks that never produced output worth printing are summarized as counts,
+     * with their names available behind --verbose.
+     */
+    private tasksNotRunSummary;
     endTasks(taskResults: TaskResult[]): void;
     printTaskTerminalOutput(task: Task, status: TaskStatus, terminalOutput: string): void;
 }