nx 23.3.0-beta.0 → 23.3.0-beta.2

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

@@ -26,9 +26,11 @@ 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");
+const nx_plugin_capabilities_1 = require("./plugins/nx-plugin-capabilities");
 const get_plugins_1 = require("./plugins/get-plugins");
 const retrieve_workspace_files_1 = require("./utils/retrieve-workspace-files");
 const handle_import_1 = require("../utils/handle-import");
@@ -39,16 +41,21 @@ const handle_import_1 = require("../utils/handle-import");
  * @throws {Error} if there is no cached ProjectGraph to read from
  */
 function readCachedProjectGraph(minimumComputedAt) {
-    const projectGraphCache = (0, nx_deps_cache_1.readProjectGraphCache)(minimumComputedAt);
-    if (!projectGraphCache) {
-        const angularSpecificError = (0, fileutils_1.fileExists)(`${workspace_root_1.workspaceRoot}/angular.json`)
-            ? (0, strip_indents_1.stripIndents) `
+    const cached = (0, nx_deps_cache_1.readProjectGraphCache)(minimumComputedAt);
+    if (!cached) {
+        throw noCachedProjectGraphError();
+    }
+    return cached.projectGraph;
+}
+function noCachedProjectGraphError() {
+    const angularSpecificError = (0, fileutils_1.fileExists)(`${workspace_root_1.workspaceRoot}/angular.json`)
+        ? (0, strip_indents_1.stripIndents) `
       Make sure invoke 'node ./decorate-angular-cli.js' in your postinstall script.
       The decorated CLI will compute the project graph.
       'ng --help' should say 'Smart Monorepos · Fast Builds'.
       `
-            : '';
-        throw new Error((0, strip_indents_1.stripIndents) `
+        : '';
+    return new Error((0, strip_indents_1.stripIndents) `
       [readCachedProjectGraph] ERROR: No cached ProjectGraph is available.
 
       If you are leveraging \`readCachedProjectGraph()\` directly then you will need to refactor your usage to first ensure that
@@ -58,8 +65,6 @@ function readCachedProjectGraph(minimumComputedAt) {
 
       ${angularSpecificError}
     `);
-    }
-    return projectGraphCache;
 }
 function readCachedProjectConfiguration(projectName) {
     const graph = readCachedProjectGraph();
@@ -85,8 +90,11 @@ function readProjectsConfigurationFromProjectGraph(projectGraph) {
 }
 async function buildProjectGraphAndSourceMapsWithoutDaemon() {
     preventRecursionInGraphConstruction();
+    // Answer from the plugins loaded below, not an earlier cached graph's rows.
+    (0, nx_plugin_capabilities_1.noteGraphReadFromCache)(undefined);
     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;
@@ -136,7 +144,12 @@ async function buildProjectGraphAndSourceMapsWithoutDaemon() {
         ...(projectGraphError?.errors ?? []),
     ];
     if (cacheEnabled) {
-        (0, nx_deps_cache_1.writeCache)(projectFileMapCache, projectGraph, sourceMaps, errors);
+        const computedAt = Date.now();
+        // Before the graph, so a cached graph never lacks its row.
+        if (errors.length === 0) {
+            (0, nx_plugin_capabilities_1.getNxPluginCapabilitiesStore)()?.record(computedAt, plugins.map((plugin) => plugin.capabilities()));
+        }
+        (0, nx_deps_cache_1.writeCache)(projectFileMapCache, projectGraph, sourceMaps, errors, computedAt);
     }
     if (errors.length > 0) {
         throw new error_types_1.ProjectGraphError(errors, projectGraph, sourceMaps);
@@ -149,14 +162,7 @@ function handleProjectGraphError(opts, e) {
     if (opts.exitOnError) {
         const isVerbose = process.env.NX_VERBOSE_LOGGING === 'true';
         if (e instanceof error_types_1.ProjectGraphError) {
-            let title = e.message;
-            const bodyLines = isVerbose
-                ? [e.stack]
-                : ['Pass --verbose to see the stacktraces.'];
-            output_1.output.error({
-                title,
-                bodyLines: bodyLines,
-            });
+            output_1.output.error((0, error_types_1.formatProjectGraphError)(e, isVerbose));
         }
         else if (typeof e.message === 'string') {
             const lines = e.message.split('\n');
@@ -178,7 +184,12 @@ function handleProjectGraphError(opts, e) {
     }
 }
 async function readCachedGraphAndHydrateFileMap(minimumComputedAt) {
-    const graph = readCachedProjectGraph(minimumComputedAt);
+    const cached = (0, nx_deps_cache_1.readProjectGraphCache)(minimumComputedAt);
+    if (!cached) {
+        throw noCachedProjectGraphError();
+    }
+    const graph = cached.projectGraph;
+    (0, nx_plugin_capabilities_1.noteGraphReadFromCache)(cached.computedAt);
     const projectRootMap = Object.fromEntries(Object.entries(graph.nodes).map(([project, { data }]) => [
         data.root,
         project,
@@ -260,45 +271,33 @@ async function createProjectGraphAndSourceMapsAsync(opts = {
         const lock = !native_1.IS_WASM
             ? new native_1.FileLock((0, path_1.join)(cache_directory_1.workspaceDataDirectory, 'project-graph.lock'))
             : null;
-        let locked = lock?.locked;
-        while (locked) {
+        let holdingLock = lock?.tryLock() ?? false;
+        while (lock && !holdingLock) {
             logger_1.logger.verbose('Waiting for graph construction in another process to complete');
             const spinner = new delayed_spinner_1.DelayedSpinner('Waiting for graph construction in another process to complete');
             const start = Date.now();
-            await lock.wait();
-            spinner.cleanup();
-            // Note: This will currently throw if any of the caches are missing...
-            // It would be nice if one of the processes that was waiting for the lock
-            // could pick up the slack and build the graph if it's missing, but
-            // we wouldn't want either of the below to happen:
-            // - All of the waiting processes to build the graph
-            // - Even one of the processes building the graph on a legitimate error
             try {
-                // Ensuring that computedAt was after this process started
-                // waiting for the graph to complete, means that the graph
-                // was computed by the process was already working.
+                await lock.wait();
+                // A graph computed after this process started waiting is the holder's.
                 const graph = await readCachedGraphAndHydrateFileMap(start);
                 const sourceMaps = (0, nx_deps_cache_1.readSourceMapsCache)();
                 if (!sourceMaps) {
                     throw new Error('The project graph was computed in another process, but the source maps are missing.');
                 }
-                return {
-                    projectGraph: graph,
-                    sourceMaps,
-                };
+                return { projectGraph: graph, sourceMaps };
             }
             catch (e) {
-                // If the error is that the cached graph is stale after unlock,
-                // the process that was working on the graph must have been canceled,
-                // so we will fall through to the normal flow to ensure
-                // its created by one of the processes that was waiting
                 if (!(e instanceof error_types_1.StaleProjectGraphCacheError)) {
                     throw e;
                 }
+                // The holder stopped without writing a graph: build it here, or wait for
+                // whoever took the lock first.
+                holdingLock = lock.tryLock();
+            }
+            finally {
+                spinner.cleanup();
             }
-            locked = lock.check();
         }
-        lock?.lock();
         try {
             const res = await buildProjectGraphAndSourceMapsWithoutDaemon();
             perf_hooks_1.performance.measure('createProjectGraphAsync >> retrieve-project-configurations', 'retrieve-project-configurations:start', 'retrieve-project-configurations:end');
@@ -323,7 +322,9 @@ async function createProjectGraphAndSourceMapsAsync(opts = {
             handleProjectGraphError(opts, e);
         }
         finally {
-            lock?.unlock();
+            if (holdingLock) {
+                lock.unlock();
+            }
         }
     }
     else {

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