nx 23.2.1 → 23.3.0-beta.1

package/dist/src/project-graph/plugins/task-results-stub.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stubTerminalOutputs = stubTerminalOutputs;
+exports.rehydrateTerminalOutputs = rehydrateTerminalOutputs;
+const node_fs_1 = require("node:fs");
+const promises_1 = require("node:fs/promises");
+const node_path_1 = require("node:path");
+const terminal_output_path_1 = require("../../tasks-runner/terminal-output-path");
+const logger_1 = require("../../utils/logger");
+function isStubbed(context) {
+    return !!context.stubbedTerminalOutputs;
+}
+/**
+ * Swaps outputs out for paths ahead of a transport. Idempotent, so a context
+ * already stubbed for the daemon can be passed on to a plugin worker as-is.
+ */
+function stubTerminalOutputs(context) {
+    if (!context.taskResults) {
+        return context;
+    }
+    const stubbedTerminalOutputs = {
+        ...(isStubbed(context) ? context.stubbedTerminalOutputs : {}),
+    };
+    const taskResults = {};
+    let swapped = false;
+    for (const [id, result] of Object.entries(context.taskResults)) {
+        const path = id in stubbedTerminalOutputs ? null : stubbablePath(result);
+        if (path) {
+            const { terminalOutput, ...withoutOutput } = result;
+            stubbedTerminalOutputs[id] = path;
+            taskResults[id] = withoutOutput;
+            swapped = true;
+        }
+        else {
+            taskResults[id] = result;
+        }
+    }
+    // Nothing to swap: hand back the context as it came, so a run with no
+    // outputs on disk sends exactly what it sent before. Covers the
+    // already-stubbed case too, which keeps its own map by staying untouched.
+    if (!swapped) {
+        return context;
+    }
+    return { ...context, taskResults, stubbedTerminalOutputs };
+}
+/**
+ * Reads the outputs back. A no-op on a context that was never stubbed, which
+ * is every in-process plugin run without the daemon.
+ *
+ * The reads are issued together rather than awaited one at a time: a run has
+ * one file per task, they are independent, and this sits between the tasks
+ * finishing and the first plugin seeing the results - so serializing it would
+ * add up every file's latency in front of that.
+ */
+async function rehydrateTerminalOutputs(context) {
+    if (!isStubbed(context)) {
+        return context;
+    }
+    const taskResults = { ...context.taskResults };
+    const reads = Object.entries(context.stubbedTerminalOutputs)
+        // A stub whose result is gone has nothing to attach the bytes to, so it is
+        // dropped before the read rather than after it.
+        .filter(([id]) => taskResults[id])
+        .map(async ([id, path]) => {
+        const terminalOutput = await readTerminalOutput(path);
+        taskResults[id] = { ...taskResults[id], terminalOutput };
+    });
+    await Promise.all(reads);
+    const { stubbedTerminalOutputs, ...rehydrated } = {
+        ...context,
+        taskResults,
+    };
+    return rehydrated;
+}
+/**
+ * The path to swap in, or null to leave the output inline. A task that failed
+ * before it was hashed has no path, and a task that never ran has no file —
+ * both keep whatever they already carry rather than losing it.
+ */
+function stubbablePath(result) {
+    if (result.terminalOutput === undefined) {
+        return null;
+    }
+    const hash = result.task?.hash;
+    if (!hash) {
+        return null;
+    }
+    // `getCustomHasher` lets a plugin return any string, and this one reaches a
+    // read, so the sink is kept inside the cache dir here rather than trusted to
+    // the hasher. A hash that needed stripping resolves to a file that does not
+    // exist, which falls back to sending the output inline.
+    const path = (0, terminal_output_path_1.terminalOutputPathForHash)((0, node_path_1.basename)(hash));
+    return (0, node_fs_1.existsSync)(path) ? path : null;
+}
+/**
+ * A path that no longer resolves means the bytes are gone. Saying so with
+ * `undefined` — already a legal value, skipped tasks have it — beats leaving
+ * the path, which would have plugins treat a filename as the output.
+ */
+async function readTerminalOutput(path) {
+    if (!path) {
+        return undefined;
+    }
+    try {
+        return await (0, promises_1.readFile)(path, 'utf-8');
+    }
+    catch (e) {
+        logger_1.logger.warn(`Nx could not read a task's terminal output from ${path}: ${e.message}`);
+        return undefined;
+    }
+}

package/dist/src/project-graph/plugins/tasks-execution-hooks.d.ts

@@ -1,3 +1,4 @@
-import type { PostTasksExecutionContext, PreTasksExecutionContext } from './public-api';
+import type { PreTasksExecutionContext } from './public-api';
+import { type MaybeStubbedPostTasksExecutionContext } from './task-results-stub';
 export declare function runPreTasksExecution(pluginContext: PreTasksExecutionContext): Promise<NodeJS.ProcessEnv[]>;
-export declare function runPostTasksExecution(context: PostTasksExecutionContext): Promise<void>;
+export declare function runPostTasksExecution(context: MaybeStubbedPostTasksExecutionContext): Promise<void>;

package/dist/src/project-graph/plugins/tasks-execution-hooks.js

@@ -7,6 +7,7 @@ const get_plugins_1 = require("./get-plugins");
 const is_on_daemon_1 = require("../../daemon/is-on-daemon");
 const client_1 = require("../../daemon/client/client");
 const workspace_root_1 = require("../../utils/workspace-root");
+const task_results_stub_1 = require("./task-results-stub");
 async function runPreTasksExecution(pluginContext) {
     if ((0, is_on_daemon_1.isOnDaemon)() || !(0, client_1.isDaemonEnabled)()) {
         performance.mark(`preTasksExecution:start`);
@@ -62,6 +63,6 @@ async function runPostTasksExecution(context) {
         performance.measure(`postTasksExecution`, `postTasksExecution:start`, `postTasksExecution:end`);
     }
     else {
-        await client_1.daemonClient.runPostTasksExecution(context);
+        await client_1.daemonClient.runPostTasksExecution((0, task_results_stub_1.stubTerminalOutputs)(context));
     }
 }

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

@@ -26,6 +26,7 @@ const logger_1 = require("../utils/logger");
 const output_1 = require("../utils/output");
 const strip_indents_1 = require("../utils/strip-indents");
 const workspace_root_1 = require("../utils/workspace-root");
+const workspace_context_1 = require("../utils/workspace-context");
 const build_project_graph_1 = require("./build-project-graph");
 const error_types_1 = require("./error-types");
 const nx_deps_cache_1 = require("./nx-deps-cache");
@@ -87,6 +88,7 @@ async function buildProjectGraphAndSourceMapsWithoutDaemon() {
     preventRecursionInGraphConstruction();
     global.NX_GRAPH_CREATION = true;
     const nxJson = (0, nx_json_1.readNxJson)();
+    (0, workspace_context_1.refreshWorkspaceContext)(workspace_root_1.workspaceRoot);
     perf_hooks_1.performance.mark('retrieve-project-configurations:start');
     let configurationResult;
     let projectConfigurationsError;

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

@@ -62,13 +62,28 @@ async function runTasks(executorName, projectGraph, batchTaskGraph, fullTaskGrap
     catch (e) {
         const isVerbose = tasks[0].overrides.verbose;
         console.error(isVerbose ? e : e.message);
+        // `process.exit` does not wait for pipe writes, so the reason this worker
+        // died could otherwise be the one line that never arrives.
+        await flushStdio();
         process.exit(1);
     }
 }
+/**
+ * Waits until everything written to stdout and stderr so far has reached the
+ * pipe. Writes to a pipe are asynchronous, and the parent learns the batch is
+ * over through a separate IPC channel - so without this it can be told the batch
+ * finished, or see the process exit, while the end of its output is still in
+ * memory here. That tail is where a tool reports what went wrong.
+ */
+function flushStdio() {
+    const flush = (stream) => new Promise((resolve) => stream.write('', () => resolve()));
+    return Promise.all([flush(process.stdout), flush(process.stderr)]).then(() => undefined);
+}
 process.on('message', async (message) => {
     switch (message.type) {
         case batch_messages_1.BatchMessageType.RunTasks: {
             const results = await runTasks(message.executorName, message.projectGraph, message.batchTaskGraph, message.fullTaskGraph);
+            await flushStdio();
             process.send({
                 type: batch_messages_1.BatchMessageType.CompleteBatchExecution,
                 results,

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

@@ -13,6 +13,23 @@ export type TaskWithCachedResult = {
 };
 export declare function dbCacheEnabled(): boolean;
 export declare function getCache(options: DefaultTasksRunnerOptions): DbCache | Cache;
+/**
+ * Collects the batch worker logs written by `batchOutputPathForKey`.
+ *
+ * Guarded rather than called straight through: `cache.rs` is
+ * `#[cfg(not(target_arch = "wasm32"))]`, so this export does not exist in the
+ * WASM binding and calling it there is a `TypeError`. Every other native cache
+ * entry point is kept off that path by `dbCacheEnabled()`; this one is a free
+ * function, so it needs its own guard. The logs are collected on the next
+ * non-WASM run.
+ */
+export declare function sweepBatchOutputs(): void;
+/**
+ * Where a batch worker's own log lives. Mirrors `batch_outputs_path` in
+ * cache.rs, which is what sweeps the directory — the same mirroring
+ * `terminalOutputPathForHash` does for `get_task_outputs_path_internal`.
+ */
+export declare function batchOutputPathForKey(key: string): string;
 export declare class DbCache {
     private readonly options;
     private nxJson;
@@ -32,6 +49,16 @@ export declare class DbCache {
     getUsedCacheSpace(): number;
     private applyRemoteCacheResults;
     put(task: Task, terminalOutput: string | null, outputs: string[], code: number): Promise<void>;
+    /**
+     * Register terminal outputs that were written outside of `put` — uncacheable
+     * tasks, and cacheable ones run with `--skip-nx-cache`. `removeOldCacheRecords`
+     * only collects hashes it finds in the database, so without this the files
+     * would never be cleaned up.
+     */
+    recordTerminalOutputs(records: {
+        hash: string;
+        size: number;
+    }[]): void;
     copyFilesFromCache(_: string, cachedResult: CachedResult, outputs: string[]): Promise<number>;
     removeOldCacheRecords(): void;
     temporaryOutputPath(task: Task): string;
@@ -63,6 +90,14 @@ export declare class Cache {
     put(task: Task, terminalOutput: string | null, outputs: string[], code: number): Promise<void>;
     copyFilesFromCache(hash: string, cachedResult: CachedResult, outputs: string[]): Promise<void>;
     temporaryOutputPath(task: Task): string;
+    /**
+     * No-op: the legacy cache has no database to record against, and its
+     * collection is directory-based rather than driven by cache records.
+     */
+    recordTerminalOutputs(_records: {
+        hash: string;
+        size: number;
+    }[]): void;
     private expandOutputsInWorkspace;
     private expandOutputsInCache;
     private _expandOutputs;

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

@@ -3,6 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Cache = exports.DbCache = void 0;
 exports.dbCacheEnabled = dbCacheEnabled;
 exports.getCache = getCache;
+exports.sweepBatchOutputs = sweepBatchOutputs;
+exports.batchOutputPathForKey = batchOutputPathForKey;
 exports.resolveMaxCacheSize = resolveMaxCacheSize;
 exports.parseMaxCacheSize = parseMaxCacheSize;
 exports.formatCacheSize = formatCacheSize;
@@ -54,6 +56,30 @@ function getCache(options) {
         })
         : new Cache(options);
 }
+/**
+ * Collects the batch worker logs written by `batchOutputPathForKey`.
+ *
+ * Guarded rather than called straight through: `cache.rs` is
+ * `#[cfg(not(target_arch = "wasm32"))]`, so this export does not exist in the
+ * WASM binding and calling it there is a `TypeError`. Every other native cache
+ * entry point is kept off that path by `dbCacheEnabled()`; this one is a free
+ * function, so it needs its own guard. The logs are collected on the next
+ * non-WASM run.
+ */
+function sweepBatchOutputs() {
+    if (native_1.IS_WASM) {
+        return;
+    }
+    (0, native_1.sweepBatchOutputs)(cache_directory_1.cacheDir);
+}
+/**
+ * Where a batch worker's own log lives. Mirrors `batch_outputs_path` in
+ * cache.rs, which is what sweeps the directory — the same mirroring
+ * `terminalOutputPathForHash` does for `get_task_outputs_path_internal`.
+ */
+function batchOutputPathForKey(key) {
+    return (0, path_1.join)(cache_directory_1.cacheDir, 'batchOutputs', `${key}.log`);
+}
 class DbCache {
     constructor(options) {
         this.options = options;
@@ -161,6 +187,15 @@ class DbCache {
             }
         });
     }
+    /**
+     * Register terminal outputs that were written outside of `put` — uncacheable
+     * tasks, and cacheable ones run with `--skip-nx-cache`. `removeOldCacheRecords`
+     * only collects hashes it finds in the database, so without this the files
+     * would never be cleaned up.
+     */
+    recordTerminalOutputs(records) {
+        this.cache.recordTerminalOutputs(records);
+    }
     copyFilesFromCache(_, cachedResult, outputs) {
         return tryAndRetry(async () => this.cache.copyFilesFromCache(cachedResult, outputs));
     }
@@ -421,6 +456,11 @@ class Cache {
     temporaryOutputPath(task) {
         return (0, path_1.join)(this.terminalOutputsDir, task.hash);
     }
+    /**
+     * No-op: the legacy cache has no database to record against, and its
+     * collection is directory-based rather than driven by cache records.
+     */
+    recordTerminalOutputs(_records) { }
     async expandOutputsInWorkspace(outputs) {
         return this._expandOutputs(outputs, workspace_root_1.workspaceRoot);
     }

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

@@ -172,6 +172,7 @@ class ProcessTasks {
                     dependencyConfig.target +
                     DUMMY_TASK_TARGET, undefined);
                 this.dependencies[task.id].push(dummyId);
+                this.continuousDependencies[task.id].push(dummyId);
                 this.dependencies[dummyId] ??= [];
                 this.continuousDependencies[dummyId] ??= [];
                 const noopTask = this.createDummyTask(dummyId, task);

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

@@ -68,7 +68,7 @@ const defaultTasksRunner = async (tasks, options, context) => {
 };
 exports.defaultTasksRunner = defaultTasksRunner;
 async function runAllTasks(options, context) {
-    const orchestrator = new task_orchestrator_1.TaskOrchestrator(context.hasher, context.initiatingProject, context.initiatingTasks, context.projectGraph, context.taskGraph, context.nxJson, options, context.nxArgs?.nxBail, context.daemon, context.nxArgs?.outputStyle);
+    const orchestrator = new task_orchestrator_1.TaskOrchestrator(context.hasher, context.initiatingProject, context.initiatingTasks, context.projectGraph, context.taskGraph, context.nxJson, options, context.nxArgs?.nxBail, context.daemon, context.nxArgs?.specifiedOutputStyle, context.nxArgs?.resolvedOutputStyle ?? 'static-failures-only');
     return orchestrator.run();
 }
 exports.default = exports.defaultTasksRunner;

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

@@ -17,7 +17,7 @@ export declare class ForkedProcessTaskRunner {
     private pseudoTerminals;
     constructor(options: DefaultTasksRunnerOptions, tuiEnabled: boolean);
     init(): Promise<void>;
-    forkProcessForBatch({ id: batchId, executorName, taskGraph: batchTaskGraph }: Batch, projectGraph: ProjectGraph, fullTaskGraph: TaskGraph, env: NodeJS.ProcessEnv): Promise<BatchProcess>;
+    forkProcessForBatch({ id: batchId, executorName, taskGraph: batchTaskGraph }: Batch, projectGraph: ProjectGraph, fullTaskGraph: TaskGraph, env: NodeJS.ProcessEnv, printsOutput?: boolean): Promise<BatchProcess>;
     cleanUpBatchProcesses(): void;
     forkProcessLegacy(task: Task, { temporaryOutputPath, streamOutput, pipeOutput, taskGraph, env, }: {
         temporaryOutputPath: string;

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

@@ -5,6 +5,7 @@ const child_process_1 = require("child_process");
 const fs_1 = require("fs");
 const path_1 = require("path");
 const output_1 = require("../utils/output");
+const prune_task_graph_1 = require("./prune-task-graph");
 const strip_indents_1 = require("../utils/strip-indents");
 const batch_messages_1 = require("./batch/batch-messages");
 const process_metrics_service_1 = require("./process-metrics-service");
@@ -29,7 +30,7 @@ class ForkedProcessTaskRunner {
         this.setupProcessEventListeners();
     }
     // TODO: vsavkin delegate terminal output printing
-    async forkProcessForBatch({ id: batchId, executorName, taskGraph: batchTaskGraph }, projectGraph, fullTaskGraph, env) {
+    async forkProcessForBatch({ id: batchId, executorName, taskGraph: batchTaskGraph }, projectGraph, fullTaskGraph, env, printsOutput = true) {
         const count = Object.keys(batchTaskGraph.tasks).length;
         if (count > 1) {
             output_1.output.logSingleLine(`Running ${output_1.output.bold(count)} ${output_1.output.bold('tasks')} with ${output_1.output.bold(executorName)}`);
@@ -50,7 +51,7 @@ class ForkedProcessTaskRunner {
             const taskIds = Object.keys(batchTaskGraph.tasks);
             (0, process_metrics_service_1.getProcessMetricsService)().registerBatch(batchId, taskIds, p.pid);
         }
-        const cp = new batch_process_1.BatchProcess(p, executorName);
+        const cp = new batch_process_1.BatchProcess(p, executorName, printsOutput, batchId);
         this.processes.add(cp);
         cp.onExit(() => {
             this.processes.delete(cp);
@@ -60,8 +61,8 @@ class ForkedProcessTaskRunner {
             type: batch_messages_1.BatchMessageType.RunTasks,
             executorName,
             projectGraph,
-            batchTaskGraph,
-            fullTaskGraph,
+            batchTaskGraph: (0, prune_task_graph_1.pruneTaskGraph)(batchTaskGraph),
+            fullTaskGraph: (0, prune_task_graph_1.pruneTaskGraph)(fullTaskGraph),
         });
         return cp;
     }
@@ -148,7 +149,7 @@ class ForkedProcessTaskRunner {
         p.send({
             targetDescription: task.target,
             overrides: task.overrides,
-            taskGraph,
+            taskGraph: (0, prune_task_graph_1.pruneTaskGraph)(taskGraph),
             isVerbose: this.verbose,
         });
         this.processes.add(p);
@@ -186,7 +187,7 @@ class ForkedProcessTaskRunner {
             p.send({
                 targetDescription: task.target,
                 overrides: task.overrides,
-                taskGraph,
+                taskGraph: (0, prune_task_graph_1.pruneTaskGraph)(taskGraph),
                 isVerbose: this.verbose,
             });
             const cp = new node_child_process_1.NodeChildProcessWithNonDirectOutput(p, {
@@ -231,7 +232,7 @@ class ForkedProcessTaskRunner {
             p.send({
                 targetDescription: task.target,
                 overrides: task.overrides,
-                taskGraph,
+                taskGraph: (0, prune_task_graph_1.pruneTaskGraph)(taskGraph),
                 isVerbose: this.verbose,
             });
             cp.onExit((code, signal) => {

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

@@ -43,7 +43,11 @@ async function createOrchestrator(tasks, projectGraph, fullTaskGraph, nxJson, li
         lifeCycle: compositedLifeCycle,
     };
     (0, run_command_1.setEnvVarsBasedOnArgs)(nxArgs, true);
-    const orchestrator = new task_orchestrator_1.TaskOrchestrator(hasher, null, tasks, projectGraph, taskGraph, nxJson, nxArgs, false, client_1.daemonClient, undefined, fullTaskGraph);
+    const orchestrator = new task_orchestrator_1.TaskOrchestrator(hasher, null, tasks, projectGraph, taskGraph, nxJson, nxArgs, false, client_1.daemonClient, 
+    // No argv on this path, so the output-style middleware never ran and both
+    // fields are unset - this always renders `static-failures-only`. `nx.json`'s
+    // `outputStyle` does not reach them; it merges under its own name.
+    nxArgs.specifiedOutputStyle, nxArgs.resolvedOutputStyle ?? 'static-failures-only', fullTaskGraph);
     await orchestrator.init();
     orchestrator.processAllScheduledTasks();
     return orchestrator;

package/dist/src/tasks-runner/is-tui-enabled.js

@@ -39,12 +39,13 @@ function shouldUseTui(nxJson, nxArgs, skipCapabilityCheck = process.env.NX_TUI_S
     if (!isCapable) {
         return false;
     }
-    if ((0, output_1.isStaticOutputStyle)(nxArgs.outputStyle) ||
-        ['stream', 'stream-without-prefixes', 'dynamic-legacy'].includes(nxArgs.outputStyle)) {
+    if ((0, output_1.isStaticOutputStyle)(nxArgs.specifiedOutputStyle) ||
+        ['summary', 'stream', 'stream-without-prefixes', 'dynamic-legacy'].includes(nxArgs.specifiedOutputStyle)) {
         // If the user has specified a non-TUI output style, we disable the TUI
         return false;
     }
-    if (nxArgs.outputStyle === 'dynamic' || nxArgs.outputStyle === 'tui') {
+    if (nxArgs.specifiedOutputStyle === 'dynamic' ||
+        nxArgs.specifiedOutputStyle === 'tui') {
         return true;
     }
     // The environment variable takes precedence over the nx.json config, but

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

@@ -53,6 +53,12 @@ export interface LifeCycle {
     setEstimatedTaskTimings?(timings: Record<string, number>): void;
     registerRunningBatch?(batchId: string, batchInfo: BatchInfo): void;
     appendBatchOutput?(batchId: string, output: string): void;
+    /**
+     * The batch worker's own log is on disk and worth reading — its tasks did not
+     * all succeed. One log per worker, so this is addressed once for the batch
+     * rather than copied into any task's output.
+     */
+    batchOutputAvailable?(batchId: string, path: string): void;
     setBatchStatus?(batchId: string, status: BatchStatus): void;
     /**
      * Set a clickable Nx Cloud link in the terminal UI: `label` is the text
@@ -81,6 +87,7 @@ export declare class CompositeLifeCycle implements LifeCycle {
     setEstimatedTaskTimings(timings: Record<string, number>): void;
     registerRunningBatch(batchId: string, batchInfo: BatchInfo): void;
     appendBatchOutput(batchId: string, output: string): void;
+    batchOutputAvailable(batchId: string, path: string): void;
     setBatchStatus(batchId: string, status: BatchStatus): void;
     setCloudLink(label: string, url: string): Promise<void>;
 }

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

@@ -130,6 +130,13 @@ class CompositeLifeCycle {
             }
         }
     }
+    batchOutputAvailable(batchId, path) {
+        for (let l of this.lifeCycles) {
+            if (l.batchOutputAvailable) {
+                l.batchOutputAvailable(batchId, path);
+            }
+        }
+    }
     setBatchStatus(batchId, status) {
         for (let l of this.lifeCycles) {
             if (l.setBatchStatus) {

package/dist/src/tasks-runner/life-cycles/summary-terminal-output-life-cycle.d.ts

@@ -0,0 +1,35 @@
+import { Task } from '../../config/task-graph';
+import type { LifeCycle, TaskResult } from '../life-cycle';
+/**
+ * Prints a run as a handful of lines rather than a transcript: counts, then one
+ * line per failure naming the file that holds its output. Task output stops
+ * being a stream to read and becomes an artifact to address, so the size of this
+ * renderer's output depends on how many tasks failed, never on how loud they
+ * were.
+ *
+ * Selected by `--output-style=summary`, and by default when Nx is driven by an
+ * AI agent, which otherwise reads thousands of lines of passing output to find
+ * the one failure.
+ */
+export declare class SummaryTerminalOutputLifeCycle implements LifeCycle {
+    private readonly tasks;
+    private readonly failed;
+    private readonly stopped;
+    private readonly completed;
+    private succeeded;
+    private cached;
+    private cloudLink;
+    private readonly batchLogs;
+    constructor(tasks: Task[]);
+    setCloudLink(label: string, url: string): void;
+    batchOutputAvailable(batchId: string, path: string): void;
+    /**
+     * Nothing is printed as tasks complete. A summary that interleaved with
+     * progress would be a transcript again.
+     */
+    printTaskTerminalOutput(): void;
+    endTasks(taskResults: TaskResult[]): void;
+    endCommand(): void;
+    private countsLine;
+    private failureBlock;
+}

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

@@ -0,0 +1,146 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SummaryTerminalOutputLifeCycle = void 0;
+const output_1 = require("../../utils/output");
+const terminal_output_path_1 = require("../terminal-output-path");
+/**
+ * Prints a run as a handful of lines rather than a transcript: counts, then one
+ * line per failure naming the file that holds its output. Task output stops
+ * being a stream to read and becomes an artifact to address, so the size of this
+ * renderer's output depends on how many tasks failed, never on how loud they
+ * were.
+ *
+ * Selected by `--output-style=summary`, and by default when Nx is driven by an
+ * AI agent, which otherwise reads thousands of lines of passing output to find
+ * the one failure.
+ */
+class SummaryTerminalOutputLifeCycle {
+    constructor(tasks) {
+        this.tasks = tasks;
+        this.failed = [];
+        this.stopped = [];
+        this.completed = new Set();
+        this.succeeded = 0;
+        this.cached = 0;
+        this.batchLogs = new Map();
+    }
+    setCloudLink(label, url) {
+        this.cloudLink = { label, url };
+    }
+    batchOutputAvailable(batchId, path) {
+        this.batchLogs.set(batchId, path);
+    }
+    /**
+     * Nothing is printed as tasks complete. A summary that interleaved with
+     * progress would be a transcript again.
+     */
+    printTaskTerminalOutput() { }
+    endTasks(taskResults) {
+        for (const { task, status, terminalOutput } of taskResults) {
+            this.completed.add(task.id);
+            switch (status) {
+                case 'failure':
+                    // Whether a log file exists is decided here, not at render time.
+                    // `persistTerminalOutputs` skips only an undefined `terminalOutput`,
+                    // so an empty one still writes a 0-byte file - truthiness, not
+                    // definedness, is what says a reader will find something there.
+                    this.failed.push({
+                        task,
+                        hasOutput: !!terminalOutput,
+                    });
+                    break;
+                case 'stopped':
+                    // Every task of a stopped batch carries `''`: the worker's partial
+                    // log is announced as the batch's own artifact now, not folded into
+                    // any task. So these address a file only when something else wrote
+                    // one, and the batch log is addressed once below.
+                    this.stopped.push({
+                        task,
+                        hasOutput: !!terminalOutput,
+                    });
+                    break;
+                case 'local-cache':
+                case 'local-cache-kept-existing':
+                case 'remote-cache':
+                    this.cached++;
+                    this.succeeded++;
+                    break;
+                default:
+                    this.succeeded++;
+            }
+        }
+    }
+    endCommand() {
+        const skipped = this.tasks.filter((t) => !this.completed.has(t.id)).length;
+        const bodyLines = [];
+        for (const { task, hasOutput } of this.failed) {
+            bodyLines.push('', ...this.failureBlock(task, hasOutput));
+        }
+        if (this.stopped.length > 0) {
+            bodyLines.push('', output_1.output.dim('Stopped before finishing:'), ...this.stopped.flatMap(({ task, hasOutput }) => {
+                const line = `${output_1.output.dim('-')} ${task.id}`;
+                return task.hash && hasOutput
+                    ? [
+                        line,
+                        output_1.output.dim(`  full log: ${(0, terminal_output_path_1.terminalOutputPathForHash)(task.hash)}`),
+                    ]
+                    : [line];
+            }));
+        }
+        if (this.batchLogs.size > 0) {
+            // One line per worker, not per task: a batch's log explains the whole
+            // batch, and no task's own output file contains it.
+            bodyLines.push('', output_1.output.dim('Batch worker logs:'));
+            for (const [batchId, path] of this.batchLogs) {
+                bodyLines.push(`${output_1.output.dim('-')} ${output_1.output.dim(`${batchId}: ${path}`)}`);
+            }
+        }
+        if (this.cloudLink) {
+            bodyLines.push('', `${this.cloudLink.label} ${this.cloudLink.url}`);
+        }
+        bodyLines.push('', output_1.output.dim('Re-run with --output-style=static to inline logs.'));
+        const title = this.countsLine(skipped);
+        if (this.failed.length > 0 || this.stopped.length > 0) {
+            output_1.output.error({ title, bodyLines });
+        }
+        else {
+            output_1.output.success({ title, bodyLines });
+        }
+    }
+    countsLine(skipped) {
+        const parts = [`${this.succeeded} succeeded`];
+        if (this.cached > 0) {
+            parts.push(`${this.cached} cached`);
+        }
+        if (this.failed.length > 0) {
+            parts.push(`${this.failed.length} failed`);
+        }
+        if (this.stopped.length > 0) {
+            parts.push(`${this.stopped.length} stopped`);
+        }
+        if (skipped > 0) {
+            parts.push(`${skipped} skipped`);
+        }
+        return `${this.tasks.length} ${this.tasks.length === 1 ? 'task' : 'tasks'}: ${parts.join(', ')}`;
+    }
+    failureBlock(task, hasOutput) {
+        // No exit code: `completeTasks` rebuilds `TaskResult.code` from the status,
+        // so every failure arrives as 1 and a task killed with 137 or a missing
+        // binary's 127 would all render `(exit 1)`. Printing a number that is
+        // always 1 to a reader whose job is to machine-read this line is worse than
+        // printing none. formatCommand is what every other renderer uses, so a task
+        // reads the same here as it does under --output-style=static.
+        const lines = [
+            `${output_1.output.colors.red('✖')} ${output_1.output.formatCommand(task.id)}`,
+        ];
+        // The log is addressed, not reproduced. `hash` is optional on the type but
+        // always set by the time a task has run — processTask hashes before it
+        // schedules — so that half only guards against printing a bogus path.
+        // `hasOutput` is the load-bearing half: no output, no file, no address.
+        if (task.hash && hasOutput) {
+            lines.push(output_1.output.dim(`  full log: ${(0, terminal_output_path_1.terminalOutputPathForHash)(task.hash)}`));
+        }
+        return lines;
+    }
+}
+exports.SummaryTerminalOutputLifeCycle = SummaryTerminalOutputLifeCycle;