@depup/nx 23.2.1-depup.8 → 23.3.0-depup.0

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;
@@ -31,8 +48,18 @@ export declare class DbCache {
     }>>;
     getUsedCacheSpace(): number;
     private applyRemoteCacheResults;
-    put(task: Task, terminalOutput: string | null, outputs: string[], code: number): Promise<void>;
-    copyFilesFromCache(_: string, cachedResult: CachedResult, outputs: string[]): Promise<number>;
+    put(task: Task, terminalOutput: string | null, outputs: string[], code: number): Promise<import("../native").OutputFile[]>;
+    /**
+     * 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<import("../native").OutputFile[]>;
     removeOldCacheRecords(): void;
     temporaryOutputPath(task: Task): string;
     private getRemoteCache;
@@ -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;
@@ -153,14 +179,24 @@ class DbCache {
     }
     async put(task, terminalOutput, outputs, code) {
         return tryAndRetry(async () => {
-            const expandedOutputs = this.cache.put(task.hash, terminalOutput, outputs, code);
+            const { expandedOutputs, files } = this.cache.put(task.hash, terminalOutput, outputs, code);
             // Notify TaskIOService of actual output files
             (0, task_io_service_1.getTaskIOService)().notifyTaskOutputs(task.id, expandedOutputs);
             if (this.remoteCache) {
                 await this.remoteCache.store(task.hash, this.cache.cacheDirectory, terminalOutput, code);
             }
+            return files;
         });
     }
+    /**
+     * 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 +457,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.d.ts

@@ -1,9 +1,20 @@
 import { ProjectGraph, ProjectGraphProjectNode } from '../config/project-graph';
 import { Task, TaskGraph } from '../config/task-graph';
 import { TargetDependencies } from '../config/nx-json';
+/**
+ * For each task, the overrides every `dependsOn` edge into it would give it,
+ * whether or not that edge created the task. `from` is the task the edge
+ * leaves; an edge crossing a project without the target is recorded against
+ * the task it started from.
+ */
+export type DependencyOverrides = Record<string, Array<{
+    from: string;
+    overrides: Record<string, unknown>;
+}>>;
 export declare class ProcessTasks {
     private readonly extraTargetDependencies;
     private readonly projectGraph;
+    private readonly recordDependencyOverrides;
     private readonly seen;
     readonly tasks: {
         [id: string]: Task;
@@ -14,18 +25,30 @@ export declare class ProcessTasks {
     readonly continuousDependencies: {
         [k: string]: string[];
     };
+    readonly dependencyOverrides: DependencyOverrides;
     private readonly allTargetNames;
-    constructor(extraTargetDependencies: TargetDependencies, projectGraph: ProjectGraph);
+    constructor(extraTargetDependencies: TargetDependencies, projectGraph: ProjectGraph, recordDependencyOverrides?: boolean);
     processTasks(projectNames: string[], targets: string[], configuration: string, overrides: Record<string, unknown>, excludeTaskDependencies: boolean): string[];
     processTask(task: Task, projectUsedToDeriveDependencies: string, configuration: string, overrides: Record<string, unknown>): void;
     private processTasksForMultipleProjects;
     private processTasksForSingleProject;
     private processTasksForDependencies;
+    private recordEdge;
     private createDummyTask;
     createTask(id: string, project: ProjectGraphProjectNode, target: string, resolvedConfiguration: string | undefined, overrides: Record<string, unknown>): Task;
     resolveConfiguration(project: ProjectGraphProjectNode, target: string, configuration: string | undefined): string;
 }
 export declare function createTaskGraph(projectGraph: ProjectGraph, extraTargetDependencies: TargetDependencies, projectNames: string[], targets: string[], configuration: string | undefined, overrides: Record<string, unknown>, excludeTaskDependencies?: boolean): TaskGraph;
+/** `createTaskGraph`, plus the overrides each dependency edge would give. */
+export declare function createTaskGraphWithDependencyOverrides(projectGraph: ProjectGraph, extraTargetDependencies: TargetDependencies, projectNames: string[], targets: string[], configuration: string | undefined, overrides: Record<string, unknown>, excludeTaskDependencies?: boolean): {
+    taskGraph: TaskGraph;
+    dependencyOverrides: DependencyOverrides;
+};
+/**
+ * `taskGraph` pruned to `keep`, as if built from `initial` alone: a kept dependency
+ * takes the overrides its edges give it. Undefined when those edges disagree or are missing.
+ */
+export declare function filterTaskGraphToSelection(projectGraph: ProjectGraph, taskGraph: TaskGraph, dependencyOverrides: DependencyOverrides, initial: Set<string>, keep: Set<string>): TaskGraph | undefined;
 /**
  * This function is used to filter out the dummy tasks from the dependencies
  * It will manipulate the dependencies object in place

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

@@ -2,6 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ProcessTasks = void 0;
 exports.createTaskGraph = createTaskGraph;
+exports.createTaskGraphWithDependencyOverrides = createTaskGraphWithDependencyOverrides;
+exports.filterTaskGraphToSelection = filterTaskGraphToSelection;
 exports.filterDummyTasks = filterDummyTasks;
 exports.getNonDummyDeps = getNonDummyDeps;
 const utils_1 = require("./utils");
@@ -10,13 +12,15 @@ const output_1 = require("../utils/output");
 const task_graph_utils_1 = require("./task-graph-utils");
 const DUMMY_TASK_TARGET = '__nx_dummy_task__';
 class ProcessTasks {
-    constructor(extraTargetDependencies, projectGraph) {
+    constructor(extraTargetDependencies, projectGraph, recordDependencyOverrides = false) {
         this.extraTargetDependencies = extraTargetDependencies;
         this.projectGraph = projectGraph;
+        this.recordDependencyOverrides = recordDependencyOverrides;
         this.seen = new Set();
         this.tasks = {};
         this.dependencies = {};
         this.continuousDependencies = {};
+        this.dependencyOverrides = {};
         const allTargetNames = new Set();
         for (const projectName in projectGraph.nodes) {
             const project = projectGraph.nodes[projectName];
@@ -126,6 +130,7 @@ class ProcessTasks {
                 this.processTask(newTask, newTask.target.project, configuration, overrides);
             }
             if (task.id !== selfTaskId) {
+                this.recordEdge(task, selfTaskId, taskOverrides);
                 if (this.tasks[selfTaskId].continuous) {
                     this.continuousDependencies[task.id].push(selfTaskId);
                 }
@@ -149,6 +154,7 @@ class ProcessTasks {
                 const depTargetId = (0, utils_1.createTaskId)(depProject.name, dependencyConfig.target, resolvedConfiguration);
                 const depTargetConfiguration = this.projectGraph.nodes[depProject.name].data.targets[dependencyConfig.target];
                 if (task.id !== depTargetId) {
+                    this.recordEdge(task, depTargetId, taskOverrides);
                     if (depTargetConfiguration.continuous) {
                         this.continuousDependencies[task.id].push(depTargetId);
                     }
@@ -172,6 +178,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);
@@ -179,6 +186,14 @@ class ProcessTasks {
             }
         }
     }
+    recordEdge(task, dependencyId, overrides) {
+        if (!this.recordDependencyOverrides) {
+            return;
+        }
+        // A dummy task keeps its creator's target, so `from` is the real task the edge started from.
+        const from = (0, utils_1.createTaskId)(task.target.project, task.target.target, task.target.configuration);
+        (this.dependencyOverrides[dependencyId] ??= []).push({ from, overrides });
+    }
     createDummyTask(id, task) {
         return {
             ...task,
@@ -207,6 +222,7 @@ class ProcessTasks {
             cache: project.data.targets[target].cache ?? false,
             parallelism: project.data.targets[target].parallelism ?? true,
             continuous: project.data.targets[target].continuous ?? false,
+            ultracache: project.data.targets[target].ultracache,
         };
     }
     resolveConfiguration(project, target, configuration) {
@@ -219,7 +235,46 @@ class ProcessTasks {
 }
 exports.ProcessTasks = ProcessTasks;
 function createTaskGraph(projectGraph, extraTargetDependencies, projectNames, targets, configuration, overrides, excludeTaskDependencies = false) {
-    const p = new ProcessTasks(extraTargetDependencies, projectGraph);
+    return buildTaskGraph(new ProcessTasks(extraTargetDependencies, projectGraph), projectNames, targets, configuration, overrides, excludeTaskDependencies);
+}
+/** `createTaskGraph`, plus the overrides each dependency edge would give. */
+function createTaskGraphWithDependencyOverrides(projectGraph, extraTargetDependencies, projectNames, targets, configuration, overrides, excludeTaskDependencies = false) {
+    const p = new ProcessTasks(extraTargetDependencies, projectGraph, true);
+    const taskGraph = buildTaskGraph(p, projectNames, targets, configuration, overrides, excludeTaskDependencies);
+    return { taskGraph, dependencyOverrides: p.dependencyOverrides };
+}
+/**
+ * `taskGraph` pruned to `keep`, as if built from `initial` alone: a kept dependency
+ * takes the overrides its edges give it. Undefined when those edges disagree or are missing.
+ */
+function filterTaskGraphToSelection(projectGraph, taskGraph, dependencyOverrides, initial, keep) {
+    const tasks = {};
+    for (const id of keep) {
+        const task = taskGraph.tasks[id];
+        if (initial.has(id)) {
+            tasks[id] = { ...task };
+            continue;
+        }
+        const edges = dependencyOverrides[id] ?? [];
+        if (!edges.length) {
+            return undefined;
+        }
+        const first = JSON.stringify(edges[0].overrides);
+        if (edges.some((e) => JSON.stringify(e.overrides) !== first)) {
+            return undefined;
+        }
+        const project = projectGraph.nodes[task.target.project];
+        const overrides = interpolateOverrides(edges[0].overrides, project.name, project.data);
+        tasks[id] = {
+            ...task,
+            overrides,
+            outputs: (0, utils_1.getOutputs)(projectGraph.nodes, task.target, overrides),
+        };
+    }
+    const pruned = (0, utils_1.removeTasksFromTaskGraph)(taskGraph, Object.keys(taskGraph.tasks).filter((id) => !keep.has(id)));
+    return { ...pruned, tasks };
+}
+function buildTaskGraph(p, projectNames, targets, configuration, overrides, excludeTaskDependencies) {
     const roots = p.processTasks(projectNames, targets, configuration, overrides, excludeTaskDependencies);
     return {
         roots,

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', context.taskGraph, context.deferredTaskIds);
     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;
     }
@@ -143,12 +144,12 @@ class ForkedProcessTaskRunner {
         // Register forked process for metrics collection
         const pid = p.getPid();
         if (pid) {
-            (0, task_io_service_1.registerTaskProcessStart)(task.id, pid);
+            (0, task_io_service_1.registerTaskProcessStart)(task, pid);
         }
         p.send({
             targetDescription: task.target,
             overrides: task.overrides,
-            taskGraph,
+            taskGraph: (0, prune_task_graph_1.pruneTaskGraph)(taskGraph),
             isVerbose: this.verbose,
         });
         this.processes.add(p);
@@ -180,13 +181,13 @@ class ForkedProcessTaskRunner {
             });
             // Register forked process for metrics collection
             if (p.pid) {
-                (0, task_io_service_1.registerTaskProcessStart)(task.id, p.pid);
+                (0, task_io_service_1.registerTaskProcessStart)(task, p.pid);
             }
             // Send message to run the executor
             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, {
@@ -223,7 +224,7 @@ class ForkedProcessTaskRunner {
             });
             // Register forked process for metrics collection
             if (p.pid) {
-                (0, task_io_service_1.registerTaskProcessStart)(task.id, p.pid);
+                (0, task_io_service_1.registerTaskProcessStart)(task, p.pid);
             }
             const cp = new node_child_process_1.NodeChildProcessWithDirectOutput(p, temporaryOutputPath);
             this.processes.add(cp);
@@ -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.d.ts

@@ -1,7 +1,12 @@
 import type { NxJsonConfiguration } from '../config/nx-json';
 import { Task, TaskGraph } from '../config/task-graph';
 import { LifeCycle, TaskResult } from './life-cycle';
+import type { UltracacheConfigurations } from '../native';
 import type { ProjectGraph } from '../config/project-graph';
 import { RunningTask } from './running-tasks/running-task';
-export declare function runDiscreteTasks(tasks: Task[], projectGraph: ProjectGraph, fullTaskGraph: TaskGraph, nxJson: NxJsonConfiguration, lifeCycle: LifeCycle): Promise<Array<Promise<TaskResult[]>>>;
-export declare function runContinuousTasks(tasks: Task[], projectGraph: ProjectGraph, fullTaskGraph: TaskGraph, nxJson: NxJsonConfiguration, lifeCycle: LifeCycle): Promise<Record<string, Promise<RunningTask>>>;
+export declare function runDiscreteTasks(tasks: Task[], projectGraph: ProjectGraph, fullTaskGraph: TaskGraph, nxJson: NxJsonConfiguration, lifeCycle: LifeCycle, 
+/** The set to hash from, e.g. from `importUltracacheConfigurations`; omitted hashes natively. */
+ultracacheConfigurations?: UltracacheConfigurations): Promise<Array<Promise<TaskResult[]>>>;
+export declare function runContinuousTasks(tasks: Task[], projectGraph: ProjectGraph, fullTaskGraph: TaskGraph, nxJson: NxJsonConfiguration, lifeCycle: LifeCycle, 
+/** The set to hash from, e.g. from `importUltracacheConfigurations`; omitted hashes natively. */
+ultracacheConfigurations?: UltracacheConfigurations): Promise<Record<string, Promise<RunningTask>>>;

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

@@ -11,7 +11,7 @@ const create_task_hasher_1 = require("../hasher/create-task-hasher");
 const client_1 = require("../daemon/client/client");
 const shared_running_task_1 = require("./running-tasks/shared-running-task");
 const task_results_life_cycle_1 = require("./life-cycles/task-results-life-cycle");
-async function createOrchestrator(tasks, projectGraph, fullTaskGraph, nxJson, lifeCycle) {
+async function createOrchestrator(tasks, projectGraph, fullTaskGraph, nxJson, lifeCycle, ultracacheConfigurations) {
     (0, dotenv_1.loadRootEnvFiles)();
     const invokeRunnerTerminalLifecycle = new invoke_runner_terminal_output_life_cycle_1.InvokeRunnerTerminalOutputLifeCycle(tasks);
     const taskResultsLifecycle = new task_results_life_cycle_1.TaskResultsLifeCycle();
@@ -21,7 +21,6 @@ async function createOrchestrator(tasks, projectGraph, fullTaskGraph, nxJson, li
         lifeCycle,
     ]);
     const { runnerOptions: options } = (0, run_command_1.getRunner)({}, nxJson);
-    let hasher = (0, create_task_hasher_1.createTaskHasher)(projectGraph, nxJson, options);
     const taskGraph = {
         roots: tasks.map((task) => task.id),
         tasks: tasks.reduce((acc, task) => {
@@ -37,13 +36,18 @@ async function createOrchestrator(tasks, projectGraph, fullTaskGraph, nxJson, li
             return acc;
         }, {}),
     };
+    const hasher = (0, create_task_hasher_1.createTaskHasher)(projectGraph, nxJson, options, ultracacheConfigurations);
     const nxArgs = {
         ...options,
         parallel: tasks.length,
         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;
@@ -53,8 +57,10 @@ async function createOrchestrator(tasks, projectGraph, fullTaskGraph, nxJson, li
 function logDisposeFailure(e) {
     console.error('Failed to dispose the task orchestrator:', e);
 }
-async function runDiscreteTasks(tasks, projectGraph, fullTaskGraph, nxJson, lifeCycle) {
-    const orchestrator = await createOrchestrator(tasks, projectGraph, fullTaskGraph, nxJson, lifeCycle);
+async function runDiscreteTasks(tasks, projectGraph, fullTaskGraph, nxJson, lifeCycle, 
+/** The set to hash from, e.g. from `importUltracacheConfigurations`; omitted hashes natively. */
+ultracacheConfigurations) {
+    const orchestrator = await createOrchestrator(tasks, projectGraph, fullTaskGraph, nxJson, lifeCycle, ultracacheConfigurations);
     let groupId = 0;
     let nextBatch = orchestrator.nextBatch();
     const batchResults = [];
@@ -92,8 +98,10 @@ async function runDiscreteTasks(tasks, projectGraph, fullTaskGraph, nxJson, life
         .catch(logDisposeFailure);
     return results;
 }
-async function runContinuousTasks(tasks, projectGraph, fullTaskGraph, nxJson, lifeCycle) {
-    const orchestrator = await createOrchestrator(tasks, projectGraph, fullTaskGraph, nxJson, lifeCycle);
+async function runContinuousTasks(tasks, projectGraph, fullTaskGraph, nxJson, lifeCycle, 
+/** The set to hash from, e.g. from `importUltracacheConfigurations`; omitted hashes natively. */
+ultracacheConfigurations) {
+    const orchestrator = await createOrchestrator(tasks, projectGraph, fullTaskGraph, nxJson, lifeCycle, ultracacheConfigurations);
     const runningTasks = tasks.reduce((current, task, index) => {
         current[task.id] = orchestrator.startContinuousTask(task, index);
         return current;

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