@depup/nx 23.1.3-depup.0 → 23.2.0-depup.0

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

@@ -20,6 +20,41 @@ class StaticRunOneTerminalOutputLifeCycle {
         this.args = args;
         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;
+    }
+    /**
+     * 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.')}`,
+        ];
     }
     startCommand() {
         const numberOfDeps = this.tasks.length - 1;
@@ -34,13 +69,17 @@ class StaticRunOneTerminalOutputLifeCycle {
     }
     endCommand() {
         output_1.output.addNewline();
-        if (this.failedTasks.length === 0) {
+        // A stopped task was killed mid-flight, so the run did not complete even
+        // though nothing outright failed — matching run-many and didCommandComplete.
+        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,
@@ -48,24 +87,71 @@ class StaticRunOneTerminalOutputLifeCycle {
         }
         else {
             output_1.output.addVerticalSeparatorWithoutNewLines('red');
-            const bodyLines = [
-                output_1.output.dim('Failed tasks:'),
-                '',
-                ...this.failedTasks.map((task) => `${output_1.output.dim('-')} ${task.id}`),
-                '',
-                `${output_1.output.dim('Hint: run the command with')} --verbose ${output_1.output.dim('for more details.')}`,
-            ];
+            const bodyLines = [];
+            const skippedTasks = this.skippedTasks();
+            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}`), '');
+            }
+            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.map((task) => `${output_1.output.dim('-')} ${task.id}`), '');
+            }
+            bodyLines.push(...this.hiddenOutputHint());
+            bodyLines.push(`${output_1.output.dim('Hint: run the command with')} --verbose ${output_1.output.dim('for more details.')}`);
+            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));
+    }
+    /**
+     * 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);
             }
@@ -79,19 +165,29 @@ class StaticRunOneTerminalOutputLifeCycle {
     }
     printTaskTerminalOutput(task, status, terminalOutput) {
         const args = (0, utils_1.getPrintableCommandArgsForTask)(task);
-        if (this.args.verbose ||
-            status === 'success' ||
+        if (this.printsFullOutput ||
             status === 'failure' ||
             task.target.project === this.initiatingProject) {
-            output_1.output.logCommandOutput(args.join(' '), status, terminalOutput);
-        }
-        else {
             /**
-             * Do not show the terminal output in the case where it is not the initiating project and verbose is not set,
-             * but still print the command that was run and its status (so that cache hits can still be traced).
+             * The task that was actually asked for always shows its full output, even
+             * on success — printing nothing for `nx build myapp` would be surprising.
+             * A stopped task's partial output is shown under --verbose or
+             * --output-style=static (what diagnoses a hang); it is dropped on the
+             * default path below.
              */
-            output_1.output.logCommandOutput(args.join(' '), status, '');
+            output_1.output.logCommandOutput(args.join(' '), status, terminalOutput);
+            return;
+        }
+        // Named in the end of run summary instead; output not shown by default.
+        if (status === 'skipped' || status === 'stopped') {
+            return;
         }
+        /**
+         * Dependency tasks collapse to a single line, so that a cache hit or a
+         * success can still be traced without carrying its whole log.
+         */
+        this.collapsedTasks++;
+        output_1.output.logCommandSummary(args.join(' '), status);
     }
 }
 exports.StaticRunOneTerminalOutputLifeCycle = StaticRunOneTerminalOutputLifeCycle;

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

@@ -77,6 +77,14 @@ class PseudoIPCServer {
                     this.childReadyMap.get(childId)();
                 }
             }
+        }, 
+        // Nothing resynchronizes a length-prefixed stream, so report it the
+        // same way a socket error is reported and let the peer see the close.
+        (err) => {
+            for (const childMessage of this.childMessages) {
+                childMessage.onError?.(err);
+            }
+            socket.destroy();
         }));
         socket.on('close', () => {
             for (const childMessage of this.childMessages) {
@@ -91,15 +99,12 @@ class PseudoIPCServer {
     }
     sendMessageToChildren(message) {
         this.sockets.forEach((socket) => {
-            socket.write((0, socket_utils_1.serialize)({ type: 'TO_CHILDREN_FROM_PARENT', message }));
-            // send EOT to indicate that the message has been fully written
-            socket.write(consume_messages_from_socket_1.MESSAGE_END_SEQ);
+            (0, socket_utils_1.sendMessage)(socket, { type: 'TO_CHILDREN_FROM_PARENT', message });
         });
     }
     sendMessageToChild(id, message) {
         this.sockets.forEach((socket) => {
-            socket.write((0, socket_utils_1.serialize)({ type: 'TO_CHILDREN_FROM_PARENT', id, message }));
-            socket.write(consume_messages_from_socket_1.MESSAGE_END_SEQ);
+            (0, socket_utils_1.sendMessage)(socket, { type: 'TO_CHILDREN_FROM_PARENT', id, message });
         });
     }
     onMessageFromChildren(onMessage, onClose = () => { }, onError = (err) => { }) {
@@ -121,17 +126,13 @@ class PseudoIPCClient {
         this.socket = (0, net_1.connect)(this.path);
     }
     sendMessageToParent(message) {
-        this.socket.write((0, socket_utils_1.serialize)({ type: 'TO_PARENT_FROM_CHILDREN', message }));
-        // send EOT to indicate that the message has been fully written
-        this.socket.write(consume_messages_from_socket_1.MESSAGE_END_SEQ);
+        (0, socket_utils_1.sendMessage)(this.socket, { type: 'TO_PARENT_FROM_CHILDREN', message });
     }
     notifyChildIsReady(id) {
-        this.socket.write((0, socket_utils_1.serialize)({
+        (0, socket_utils_1.sendMessage)(this.socket, {
             type: 'CHILD_READY',
             message: id,
-        }));
-        // send EOT to indicate that the message has been fully written
-        this.socket.write(consume_messages_from_socket_1.MESSAGE_END_SEQ);
+        });
     }
     onMessageFromParent(forkId, onMessage, onClose = () => { }, onError = (err) => { }) {
         this.socket.on('data', (0, consume_messages_from_socket_1.consumeMessagesFromSocket)(async (rawMessage) => {
@@ -144,7 +145,7 @@ class PseudoIPCClient {
                     onMessage(message);
                 }
             }
-        }));
+        }, onError));
         this.socket.on('close', onClose);
         this.socket.on('error', onError);
         return this;

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

@@ -34,11 +34,25 @@ export declare class PseudoTerminal {
 export declare class PseudoTtyProcess implements RunningTask {
     rustPseudoTerminal: RustPseudoTerminal;
     private childProcess;
+    /**
+     * Whether the native side is suppressing this task's output. When it is
+     * not, Rust writes each chunk straight to our stdout, so `CLIOutput` has to
+     * be told - it never sees those writes and would otherwise assume the
+     * cursor is still at a line start.
+     */
+    private readonly quiet;
     isAlive: boolean;
     private exitCallbacks;
     private outputCallbacks;
     private terminalOutputChunks;
-    constructor(rustPseudoTerminal: RustPseudoTerminal, childProcess: ChildProcess);
+    constructor(rustPseudoTerminal: RustPseudoTerminal, childProcess: ChildProcess, 
+    /**
+     * Whether the native side is suppressing this task's output. When it is
+     * not, Rust writes each chunk straight to our stdout, so `CLIOutput` has to
+     * be told - it never sees those writes and would otherwise assume the
+     * cursor is still at a line start.
+     */
+    quiet?: boolean);
     getResults(): Promise<{
         code: number;
         terminalOutput: string;
@@ -47,12 +61,12 @@ export declare class PseudoTtyProcess implements RunningTask {
     onOutput(callback: (message: string) => void): void;
     getPid(): number | undefined;
     kill(s?: NodeJS.Signals): Promise<void>;
-    getParserAndWriter(): import("../native").ExternalObject<[import("../native").ParserArc, import("../native").WriterArc]>;
+    getPtyHandles(): import("../native").ExternalObject<[import("../native").ParserArc, import("../native").WriterArc, import("../native").MasterArc]>;
 }
 export declare class PseudoTtyProcessWithSend extends PseudoTtyProcess {
     rustPseudoTerminal: RustPseudoTerminal;
     private id;
     private pseudoIpc;
-    constructor(rustPseudoTerminal: RustPseudoTerminal, _childProcess: ChildProcess, id: string, pseudoIpc: PseudoIPCServer);
+    constructor(rustPseudoTerminal: RustPseudoTerminal, _childProcess: ChildProcess, id: string, pseudoIpc: PseudoIPCServer, quiet?: boolean);
     send(message: Serializable): void;
 }

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

@@ -6,6 +6,7 @@ const tslib_1 = require("tslib");
 const os = tslib_1.__importStar(require("os"));
 const socket_utils_1 = require("../daemon/socket-utils");
 const native_1 = require("../native");
+const output_1 = require("../utils/output");
 const pseudo_ipc_1 = require("./pseudo-ipc");
 const exit_codes_1 = require("../utils/exit-codes");
 // Kill any children still alive when Nx exits. Terminals remove themselves once
@@ -69,7 +70,7 @@ class PseudoTerminal {
         }
     }
     runCommand(command, { cwd, execArgv, jsEnv, quiet, tty, } = {}) {
-        const cp = new PseudoTtyProcess(this.rustPseudoTerminal, this.rustPseudoTerminal.runCommand(command, cwd, jsEnv, execArgv, quiet, tty));
+        const cp = new PseudoTtyProcess(this.rustPseudoTerminal, this.rustPseudoTerminal.runCommand(command, cwd, jsEnv, execArgv, quiet, tty), quiet);
         this.childProcesses.add(cp);
         cp.onExit(() => this.releaseChild(cp));
         return cp;
@@ -78,7 +79,7 @@ class PseudoTerminal {
         if (!this.initialized) {
             throw new Error('Call init() before forking processes');
         }
-        const cp = new PseudoTtyProcessWithSend(this.rustPseudoTerminal, this.rustPseudoTerminal.fork(id, script, this.pseudoIPCPath, cwd, jsEnv, execArgv, quiet, commandLabel), id, this.pseudoIPC);
+        const cp = new PseudoTtyProcessWithSend(this.rustPseudoTerminal, this.rustPseudoTerminal.fork(id, script, this.pseudoIPCPath, cwd, jsEnv, execArgv, quiet, commandLabel), id, this.pseudoIPC, quiet);
         this.childProcesses.add(cp);
         cp.onExit(() => this.releaseChild(cp));
         await this.pseudoIPC.waitForChildReady(id);
@@ -93,16 +94,27 @@ class PseudoTerminal {
 }
 exports.PseudoTerminal = PseudoTerminal;
 class PseudoTtyProcess {
-    constructor(rustPseudoTerminal, childProcess) {
+    constructor(rustPseudoTerminal, childProcess, 
+    /**
+     * Whether the native side is suppressing this task's output. When it is
+     * not, Rust writes each chunk straight to our stdout, so `CLIOutput` has to
+     * be told - it never sees those writes and would otherwise assume the
+     * cursor is still at a line start.
+     */
+    quiet = false) {
         this.rustPseudoTerminal = rustPseudoTerminal;
         this.childProcess = childProcess;
+        this.quiet = quiet;
         this.isAlive = true;
         this.exitCallbacks = [];
         this.outputCallbacks = [];
         this.terminalOutputChunks = [];
-        childProcess.onOutput((output) => {
-            this.terminalOutputChunks.push(output);
-            this.outputCallbacks.forEach((cb) => cb(output));
+        childProcess.onOutput((chunk) => {
+            if (!this.quiet) {
+                output_1.output.noteExternalWrite(chunk);
+            }
+            this.terminalOutputChunks.push(chunk);
+            this.outputCallbacks.forEach((cb) => cb(chunk));
         });
         childProcess.onExit((message) => {
             this.isAlive = false;
@@ -150,14 +162,14 @@ class PseudoTtyProcess {
             }
         }
     }
-    getParserAndWriter() {
-        return this.childProcess.getParserAndWriter();
+    getPtyHandles() {
+        return this.childProcess.getPtyHandles();
     }
 }
 exports.PseudoTtyProcess = PseudoTtyProcess;
 class PseudoTtyProcessWithSend extends PseudoTtyProcess {
-    constructor(rustPseudoTerminal, _childProcess, id, pseudoIpc) {
-        super(rustPseudoTerminal, _childProcess);
+    constructor(rustPseudoTerminal, _childProcess, id, pseudoIpc, quiet = false) {
+        super(rustPseudoTerminal, _childProcess, quiet);
         this.rustPseudoTerminal = rustPseudoTerminal;
         this.id = id;
         this.pseudoIpc = pseudoIpc;

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

@@ -8,7 +8,7 @@ exports.constructLifeCycles = constructLifeCycles;
 exports.getRunner = getRunner;
 exports.getRunnerOptions = getRunnerOptions;
 const tslib_1 = require("tslib");
-const enquirer_1 = require("enquirer");
+const prompt_helpers_1 = require("../utils/prompt-helpers");
 const node_util_1 = require("node:util");
 const nx_json_1 = require("../config/nx-json");
 const client_1 = require("../daemon/client/client");
@@ -39,6 +39,7 @@ const store_run_information_life_cycle_1 = require("./life-cycles/store-run-info
 const task_history_life_cycle_1 = require("./life-cycles/task-history-life-cycle");
 const task_profiling_life_cycle_1 = require("./life-cycles/task-profiling-life-cycle");
 const performance_life_cycle_1 = require("./life-cycles/performance-life-cycle");
+const performance_report_1 = require("./life-cycles/performance-report");
 const task_results_life_cycle_1 = require("./life-cycles/task-results-life-cycle");
 const task_telemetry_life_cycle_1 = require("./life-cycles/task-telemetry-life-cycle");
 const task_timings_life_cycle_1 = require("./life-cycles/task-timings-life-cycle");
@@ -80,12 +81,15 @@ async function getTerminalOutputLifeCycle(initiatingProject, initiatingTasks, pr
     if (tasks.length === 1 && !is_tui_enabled_1.ORIGINAL_TUI_ENV_VALUE) {
         process.env.NX_TUI = 'false';
     }
+    // Kick off in the background so the URL is ready by the exit report. A brief
+    // sync preamble (git remote + axios load) runs here; the network call does not.
+    (0, performance_report_1.prefetchRemoteCacheOnboardingUrl)(nxJson);
     if ((0, is_tui_enabled_1.isTuiEnabled)()) {
         const interceptedNxCloudLogs = [];
         // Resolve where the Nx Cloud client bundle actually loads from so the
-        // stack-trace check below matches its frames. It is NOT always
-        // `{workspaceRoot}/.nx/cache/cloud`: in a git worktree the cache dir is
-        // shared with the main repo, and it can also be relocated via
+        // stack-trace check below matches its frames. It is essentially never
+        // `{workspaceRoot}/.nx/cache/cloud`: the cache normally lives in the shared
+        // per-user `~/.nx/<hash>/cache`, and it can also be relocated via
         // NX_CACHE_DIRECTORY, a custom `cacheDirectory` in nx.json, or the lerna
         // `node_modules/.cache` location. Using the client's own resolver keeps the
         // interception working in all of those cases.
@@ -169,7 +173,7 @@ async function getTerminalOutputLifeCycle(initiatingProject, initiatingTasks, pr
         const lifeCycles = [tsLifeCycle];
         // Only run the TUI if there are tasks to run
         if (tasks.length > 0) {
-            appLifeCycle = new AppLifeCycle(tasks, initiatingTasks.map((t) => t.id), isRunOne ? 0 /* RunMode.RunOne */ : 1 /* RunMode.RunMany */, pinnedTasks, nxArgs ?? {}, nxJson.tui ?? {}, titleText, workspace_root_1.workspaceRoot, taskGraph);
+            appLifeCycle = new AppLifeCycle(tasks, initiatingTasks.map((t) => t.id), isRunOne ? 0 /* RunMode.RunOne */ : 1 /* RunMode.RunMany */, pinnedTasks, nxArgs ?? {}, nxJson.tui ?? {}, titleText, workspace_root_1.workspaceRoot, taskGraph, (0, nx_cloud_utils_1.isNxCloudUsed)(nxJson));
             // The native endCommand renders the perf report in the exit popup; the runner
             // sources the payload and CompositeLifeCycle forwards it here.
             lifeCycles.unshift(appLifeCycle);
@@ -595,23 +599,19 @@ async function ensureWorkspaceIsInSyncAndGetGraphs(projectGraph, nxJson, project
 }
 async function promptForApplyingSyncGeneratorChanges() {
     try {
-        const promptConfig = {
-            name: 'applyChanges',
-            type: 'autocomplete',
-            message: 'Would you like to sync the identified changes to get your workspace up to date?',
+        // No footer slot, so the opt-out note is part of the message.
+        const applyChanges = await (0, prompt_helpers_1.selectPrompt)({
+            message: `Would you like to sync the identified changes to get your workspace up to date?${pc.dim('\nYou can skip this prompt by setting the `sync.applyChanges` option to `true` in your `nx.json`.\nFor more information, refer to the docs: https://nx.dev/concepts/sync-generators.')}`,
             choices: [
+                { value: 'yes', label: 'Yes, sync the changes and run the tasks' },
                 {
-                    name: 'yes',
-                    message: 'Yes, sync the changes and run the tasks',
-                },
-                {
-                    name: 'no',
-                    message: 'No, run the tasks without syncing the changes',
+                    value: 'no',
+                    label: 'No, run the tasks without syncing the changes',
                 },
             ],
-            footer: () => pc.dim('\nYou can skip this prompt by setting the `sync.applyChanges` option to `true` in your `nx.json`.\nFor more information, refer to the docs: https://nx.dev/concepts/sync-generators.'),
-        };
-        return await (0, enquirer_1.prompt)([promptConfig]).then(({ applyChanges }) => applyChanges === 'yes');
+            onCancel: () => process.exit(1),
+        });
+        return applyChanges === 'yes';
     }
     catch {
         process.exit(1);
@@ -619,26 +619,15 @@ async function promptForApplyingSyncGeneratorChanges() {
 }
 async function confirmRunningTasksWithSyncFailures() {
     try {
-        const promptConfig = {
-            name: 'runTasks',
-            type: 'autocomplete',
-            message: 'Would you like to ignore the sync failures and continue running the tasks?',
+        const runTasks = await (0, prompt_helpers_1.selectPrompt)({
+            message: `Would you like to ignore the sync failures and continue running the tasks?${pc.dim(`\nWhen running in CI and there are sync failures, the tasks won't run. Addressing the errors above is highly recommended to prevent failures in CI.`)}`,
             choices: [
-                {
-                    name: 'yes',
-                    message: 'Yes, ignore the failures and run the tasks',
-                },
-                {
-                    name: 'no',
-                    message: `No, don't run the tasks`,
-                },
+                { value: 'yes', label: 'Yes, ignore the failures and run the tasks' },
+                { value: 'no', label: `No, don't run the tasks` },
             ],
-            footer: () => pc.dim(`\nWhen running in CI and there are sync failures, the tasks won't run. Addressing the errors above is highly recommended to prevent failures in CI.`),
-        };
-        const runTasks = await (0, enquirer_1.prompt)([
-            promptConfig,
-        ]).then(({ runTasks }) => runTasks === 'yes');
-        if (!runTasks) {
+            onCancel: () => process.exit(1),
+        });
+        if (runTasks !== 'yes') {
             process.exit(1);
         }
     }
@@ -647,9 +636,13 @@ async function confirmRunningTasksWithSyncFailures() {
     }
 }
 function setEnvVarsBasedOnArgs(nxArgs, loadDotEnvFiles) {
+    // Batch mode turns on streaming implicitly, but streamed output interleaves
+    // between tasks and so cannot be wrapped in collapsible log groups. Where
+    // grouping applies, let it win over the implicit request; an output style the
+    // user asked for explicitly still wins over grouping.
+    const batchMode = process.env.NX_BATCH_MODE === 'true' || nxArgs.batch;
     if (nxArgs.outputStyle == 'stream' ||
-        process.env.NX_BATCH_MODE === 'true' ||
-        nxArgs.batch) {
+        (batchMode && !(0, output_1.isLogGroupingEnabled)())) {
         process.env.NX_STREAM_OUTPUT = 'true';
         process.env.NX_PREFIX_OUTPUT = 'true';
     }
@@ -795,7 +788,7 @@ function shouldUseDynamicLifeCycle(tasks, options, outputStyle) {
         return false;
     if ((0, is_ci_1.isCI)())
         return false;
-    if (outputStyle === 'static' ||
+    if ((0, output_1.isStaticOutputStyle)(outputStyle) ||
         outputStyle === 'stream' ||
         outputStyle === 'stream-without-prefixes')
         return false;

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

@@ -8,11 +8,66 @@ export declare class BatchProcess {
     private batchResultsCallbacks;
     private taskResultsCallbacks;
     private outputCallbacks;
+    /**
+     * File holding all stdout/stderr held back from the live stream under log
+     * grouping. It is rendered as a fold by a full-output run and by any batch
+     * that reported a failed or stopped task (alongside per-task rendering), and
+     * by any batch that crashed or was stopped before reporting (with redirect
+     * lines — no per-task blocks exist there), so that a diagnostic no task
+     * claimed — a crash, a config-phase error, a runner's summary — is not lost.
+     * Only a batch whose every task succeeded on the default style discards it
+     * unread. Crashiness is unknowable while capturing, so it is always written.
+     *
+     * It goes to disk rather than a string because a batch is long-lived (Gradle
+     * runs one for the whole command) and its output has no bound. Accumulating
+     * that in memory grows without limit and eventually exceeds the maximum
+     * length of a JS string.
+     */
+    private capturedOutputPath;
+    private capturedOutputFd;
+    /**
+     * Set once the capture is released. A chunk can still arrive after that —
+     * stdout delivers past the exit event — and reopening then would mint a
+     * second numbered file that nothing ever cleans up.
+     */
+    private capturedOutputDiscarded;
+    /**
+     * Set when writing the capture failed. Distinct from discarded: the bytes
+     * already on disk are still the best record of the batch, so the file is kept
+     * and rendered, while everything after the failure goes live to the terminal.
+     */
+    private capturedOutputFailed;
+    private static capturedOutputCount;
     constructor(childProcess: ChildProcess, executorName: string);
     onExit(cb: (code: number) => void): void;
     onBatchResults(cb: (results: BatchResults) => void): void;
     onTaskResults(cb: (task: string, result: TaskResult) => void): void;
     onOutput(cb: (output: string) => void): void;
+    private capture;
+    /**
+     * Path to the file holding everything held back from the live stream under
+     * log grouping, or undefined if nothing was captured. Used to render the whole
+     * batch as one fold, so output no task claimed is not lost.
+     *
+     * The file is deliberately left open rather than closed here. A worker's
+     * stdout can deliver after its exit event — which is what `getResults()`
+     * settles on — and leaving the fd open keeps such a chunk appending to this
+     * same file instead of minting a second numbered one that nothing cleans up.
+     * The caller reads the file once, synchronously, while rendering the fold, so
+     * anything arriving after that read is not shown; writes are unbuffered, so
+     * the read always sees a complete prefix of what has arrived by then.
+     */
+    getCapturedOutputPath(): string | undefined;
+    /** Releases the capture file. Safe to call more than once. */
+    discardCapturedOutput(): void;
+    /**
+     * Closes the fd and unlinks the file, leaving no path behind for a caller to
+     * read. Tolerates a partially-initialized capture, since it also runs when
+     * opening or writing the file is what failed.
+     */
+    private releaseCapturedOutput;
+    /** Closes the fd, keeping the file and its path readable. */
+    private closeCapturedOutput;
     getResults(): Promise<BatchResults>;
     send(message: Serializable): void;
     kill(signal?: NodeJS.Signals): Promise<void>;