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

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;

package/dist/src/tasks-runner/prune-task-graph.d.ts

@@ -0,0 +1,17 @@
+import type { TaskGraph } from '../config/task-graph';
+/**
+ * Everything written onto a task as a run progresses: hashes and hash
+ * details by the hasher, timings by the orchestrator, terminal output by the
+ * Nx Cloud life cycle. Nothing that receives a task graph over a socket or
+ * a fork needs any of it. The daemon recomputes hashes, and a worker learns
+ * its own from `NX_TASK_HASH`; hash details are read only by Nx Cloud on the
+ * runner side.
+ */
+export declare const TASK_RESULT_FIELDS: readonly ['hash', 'hashDetails', 'startTime', 'endTime', 'terminalOutput'];
+/**
+ * A copy of the graph with `TASK_RESULT_FIELDS` removed from every task, made
+ * once per graph object. Structure and the remaining fields are fixed once a
+ * graph is built and only result fields change during a run, so the copy
+ * never goes stale, and the source graph is untouched.
+ */
+export declare function pruneTaskGraph(taskGraph: TaskGraph): TaskGraph;

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

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TASK_RESULT_FIELDS = void 0;
+exports.pruneTaskGraph = pruneTaskGraph;
+/**
+ * Everything written onto a task as a run progresses: hashes and hash
+ * details by the hasher, timings by the orchestrator, terminal output by the
+ * Nx Cloud life cycle. Nothing that receives a task graph over a socket or
+ * a fork needs any of it. The daemon recomputes hashes, and a worker learns
+ * its own from `NX_TASK_HASH`; hash details are read only by Nx Cloud on the
+ * runner side.
+ */
+exports.TASK_RESULT_FIELDS = [
+    'hash',
+    'hashDetails',
+    'startTime',
+    'endTime',
+    'terminalOutput',
+];
+const prunedGraphs = new WeakMap();
+/**
+ * A copy of the graph with `TASK_RESULT_FIELDS` removed from every task, made
+ * once per graph object. Structure and the remaining fields are fixed once a
+ * graph is built and only result fields change during a run, so the copy
+ * never goes stale, and the source graph is untouched.
+ */
+function pruneTaskGraph(taskGraph) {
+    let pruned = prunedGraphs.get(taskGraph);
+    if (pruned)
+        return pruned;
+    const tasks = {};
+    for (const id in taskGraph.tasks) {
+        const task = taskGraph.tasks[id];
+        const copy = {};
+        for (const key in task) {
+            if (!exports.TASK_RESULT_FIELDS.includes(key)) {
+                copy[key] = task[key];
+            }
+        }
+        tasks[id] = copy;
+    }
+    pruned = { ...taskGraph, tasks };
+    prunedGraphs.set(taskGraph, pruned);
+    return pruned;
+}

package/dist/src/tasks-runner/run-command.d.ts

@@ -1,17 +1,42 @@
-import { NxJsonConfiguration } from '../config/nx-json';
-import { ProjectGraph, ProjectGraphProjectNode } from '../config/project-graph';
+import { NxJsonConfiguration, TargetDependencies } from '../config/nx-json';
+import { ProjectGraph } from '../config/project-graph';
 import { Task, TaskGraph } from '../config/task-graph';
 import { TargetDependencyConfig } from '../config/workspace-json-project-json';
 import { NxArgs } from '../utils/command-line-utils';
+import { type UltracacheConfigurationOutcome } from '../ultracache/store';
+import type { TaskPlanningContext } from '../hasher/task-planning-context';
+/** What a command runs. */
+export interface TaskSelection {
+    taskGraph: TaskGraph;
+    /**
+     * The tasks the command asked for, as opposed to ones pulled in as
+     * dependencies. A graph rebuilt after a sync is built from their projects.
+     */
+    initiatingTaskIds: string[];
+    /**
+     * What a rebuilt graph is pruned to: the selected tasks and everything they
+     * depend on. Unset keeps the whole rebuilt graph.
+     */
+    taskIds?: string[];
+    /** The planner selection used. It remembers those plans, so hashing the run reuses them. */
+    planningContext?: TaskPlanningContext;
+    /** The Ultracache configurations selection planned with; the run hashes with the same ones. */
+    ultracacheConfigurationOutcome?: UltracacheConfigurationOutcome | null;
+}
 import { LifeCycle, TaskResult, TaskResults } from './life-cycle';
 import { TasksRunner } from './tasks-runner';
-export declare function runCommand(projectsToRun: ProjectGraphProjectNode[], currentProjectGraph: ProjectGraph, { nxJson }: {
+/**
+ * `targets` on whole projects, as `run-many` runs them: every task of the
+ * projects' targets and what they depend on, with those tasks initiating.
+ */
+export declare function selectTasksForProjects(projectGraph: ProjectGraph, projectNames: string[], nxArgs: NxArgs, overrides: any, extraTargetDependencies: TargetDependencies, excludeTaskDependencies: boolean): TaskSelection;
+export declare function runCommand(taskSelection: TaskSelection, currentProjectGraph: ProjectGraph, { nxJson }: {
     nxJson: NxJsonConfiguration;
 }, nxArgs: NxArgs, overrides: any, initiatingProject: string | null, extraTargetDependencies: Record<string, (TargetDependencyConfig | string)[]>, extraOptions: {
     excludeTaskDependencies: boolean;
     loadDotEnvFiles: boolean;
 }): Promise<NodeJS.Process['exitCode']>;
-export declare function runCommandForTasks(projectsToRun: ProjectGraphProjectNode[], currentProjectGraph: ProjectGraph, { nxJson }: {
+export declare function runTasksForCommand(taskSelection: TaskSelection, currentProjectGraph: ProjectGraph, { nxJson }: {
     nxJson: NxJsonConfiguration;
 }, nxArgs: NxArgs, overrides: any, initiatingProject: string | null, extraTargetDependencies: Record<string, (TargetDependencyConfig | string)[]>, extraOptions: {
     excludeTaskDependencies: boolean;
@@ -21,7 +46,7 @@ export declare function runCommandForTasks(projectsToRun: ProjectGraphProjectNod
     completed: boolean;
 }>;
 export declare function setEnvVarsBasedOnArgs(nxArgs: NxArgs, loadDotEnvFiles: boolean): void;
-export declare function invokeTasksRunner({ tasks, projectGraph, taskGraph, lifeCycle, nxJson, nxArgs, loadDotEnvFiles, initiatingProject, initiatingTasks, }: {
+export declare function invokeTasksRunner({ tasks, projectGraph, taskGraph, lifeCycle, nxJson, nxArgs, loadDotEnvFiles, initiatingProject, initiatingTasks, planningContext, ultracacheConfigurationOutcome: loadedUltracacheConfigurationOutcome, }: {
     tasks: Task[];
     projectGraph: ProjectGraph;
     taskGraph: TaskGraph;
@@ -31,10 +56,21 @@ export declare function invokeTasksRunner({ tasks, projectGraph, taskGraph, life
     loadDotEnvFiles: boolean;
     initiatingProject: string | null;
     initiatingTasks: Task[];
+    planningContext?: TaskPlanningContext;
+    /** Already loaded for this command; `undefined` loads it here. */
+    ultracacheConfigurationOutcome?: UltracacheConfigurationOutcome | null;
 }): Promise<{
     [id: string]: TaskResult;
 }>;
 export declare function constructLifeCycles(lifeCycle: LifeCycle, taskGraph: TaskGraph, nxJson?: NxJsonConfiguration, skipNxCache?: boolean): LifeCycle[];
+/**
+ * What affected task selection reads from the runner options, so it plans as
+ * the run hashes. The Ultracache configurations are loaded once, for selection and the run.
+ */
+export declare function runnerInputsForSelection(nxArgs: NxArgs, nxJson: NxJsonConfiguration): Promise<{
+    ultracacheConfigurationOutcome: UltracacheConfigurationOutcome | null;
+    selectivelyHashTsConfig: boolean;
+}>;
 export declare function getRunner(nxArgs: NxArgs, nxJson: NxJsonConfiguration): {
     tasksRunner: TasksRunner;
     runnerOptions: any;

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

@@ -1,10 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.selectTasksForProjects = selectTasksForProjects;
 exports.runCommand = runCommand;
-exports.runCommandForTasks = runCommandForTasks;
+exports.runTasksForCommand = runTasksForCommand;
 exports.setEnvVarsBasedOnArgs = setEnvVarsBasedOnArgs;
 exports.invokeTasksRunner = invokeTasksRunner;
 exports.constructLifeCycles = constructLifeCycles;
+exports.runnerInputsForSelection = runnerInputsForSelection;
 exports.getRunner = getRunner;
 exports.getRunnerOptions = getRunnerOptions;
 const tslib_1 = require("tslib");
@@ -23,6 +25,9 @@ const is_ci_1 = require("../utils/is-ci");
 const nx_cloud_utils_1 = require("../utils/nx-cloud-utils");
 const update_manager_1 = require("../nx-cloud/update-manager");
 const logger_1 = require("../utils/logger");
+const overrides_1 = require("../ultracache/overrides");
+const report_1 = require("../ultracache/report");
+const store_1 = require("../ultracache/store");
 const nx_key_1 = require("../utils/nx-key");
 const output_1 = require("../utils/output");
 const configure_ai_agents_disclaimer_1 = require("../ai/configure-ai-agents-disclaimer");
@@ -35,6 +40,7 @@ const dynamic_run_many_terminal_output_life_cycle_1 = require("./life-cycles/dyn
 const dynamic_run_one_terminal_output_life_cycle_1 = require("./life-cycles/dynamic-run-one-terminal-output-life-cycle");
 const static_run_many_terminal_output_life_cycle_1 = require("./life-cycles/static-run-many-terminal-output-life-cycle");
 const static_run_one_terminal_output_life_cycle_1 = require("./life-cycles/static-run-one-terminal-output-life-cycle");
+const summary_terminal_output_life_cycle_1 = require("./life-cycles/summary-terminal-output-life-cycle");
 const store_run_information_life_cycle_1 = require("./life-cycles/store-run-information-life-cycle");
 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");
@@ -82,7 +88,7 @@ async function getTerminalOutputLifeCycle(initiatingProject, initiatingTasks, pr
         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.
+    // sync preamble (git remote lookup) runs here; the network call does not.
     (0, performance_report_1.prefetchRemoteCacheOnboardingUrl)(nxJson);
     if ((0, is_tui_enabled_1.isTuiEnabled)()) {
         const interceptedNxCloudLogs = [];
@@ -265,8 +271,14 @@ async function getTerminalOutputLifeCycle(initiatingProject, initiatingTasks, pr
             renderIsDone,
         };
     }
+    if (nxArgs.resolvedOutputStyle === 'summary') {
+        return {
+            lifeCycle: new summary_terminal_output_life_cycle_1.SummaryTerminalOutputLifeCycle(tasks),
+            renderIsDone: Promise.resolve(),
+        };
+    }
     const { runnerOptions } = getRunner(nxArgs, nxJson);
-    const useDynamicOutput = shouldUseDynamicLifeCycle(tasks, runnerOptions, nxArgs.outputStyle);
+    const useDynamicOutput = shouldUseDynamicLifeCycle(tasks, runnerOptions, nxArgs.specifiedOutputStyle);
     if (isRunOne) {
         if (useDynamicOutput) {
             return await (0, dynamic_run_one_terminal_output_life_cycle_1.createRunOneDynamicOutputRenderer)({
@@ -298,8 +310,22 @@ async function getTerminalOutputLifeCycle(initiatingProject, initiatingTasks, pr
         }
     }
 }
-function createTaskGraphAndRunValidations(projectGraph, extraTargetDependencies, projectNames, nxArgs, overrides, extraOptions) {
-    const taskGraph = (0, create_task_graph_1.createTaskGraph)(projectGraph, extraTargetDependencies, projectNames, nxArgs.targets, nxArgs.configuration, overrides, extraOptions.excludeTaskDependencies);
+/**
+ * `targets` on whole projects, as `run-many` runs them: every task of the
+ * projects' targets and what they depend on, with those tasks initiating.
+ */
+function selectTasksForProjects(projectGraph, projectNames, nxArgs, overrides, extraTargetDependencies, excludeTaskDependencies) {
+    const taskGraph = (0, create_task_graph_1.createTaskGraph)(projectGraph, extraTargetDependencies, projectNames, nxArgs.targets, nxArgs.configuration, overrides, excludeTaskDependencies);
+    const projects = new Set(projectNames);
+    return {
+        taskGraph,
+        initiatingTaskIds: Object.values(taskGraph.tasks)
+            .filter((t) => projects.has(t.target.project) &&
+            nxArgs.targets.includes(t.target.target))
+            .map((t) => t.id),
+    };
+}
+function runValidations(projectGraph, taskGraph, nxArgs) {
     (0, task_graph_utils_1.assertTaskGraphDoesNotContainInvalidTargets)(taskGraph);
     const cycle = (0, task_graph_utils_1.findCycle)(taskGraph);
     if (cycle) {
@@ -325,7 +351,7 @@ function createTaskGraphAndRunValidations(projectGraph, extraTargetDependencies,
     }
     return taskGraph;
 }
-async function runCommand(projectsToRun, currentProjectGraph, { nxJson }, nxArgs, overrides, initiatingProject, extraTargetDependencies, extraOptions) {
+async function runCommand(taskSelection, currentProjectGraph, { nxJson }, nxArgs, overrides, initiatingProject, extraTargetDependencies, extraOptions) {
     const status = await (0, handle_errors_1.handleErrors)(process.env.NX_VERBOSE_LOGGING === 'true', async () => {
         const id = (0, native_1.hashArray)([...process.argv, Date.now().toString()]);
         await (0, tasks_execution_hooks_1.runPreTasksExecution)({
@@ -335,7 +361,7 @@ async function runCommand(projectsToRun, currentProjectGraph, { nxJson }, nxArgs
             argv: process.argv,
         });
         const startTime = Date.now();
-        const { taskResults, completed } = await runCommandForTasks(projectsToRun, currentProjectGraph, { nxJson }, {
+        const { taskResults, completed } = await runTasksForCommand(taskSelection, currentProjectGraph, { nxJson }, {
             ...nxArgs,
             skipNxCache: nxArgs.skipNxCache ||
                 process.env.NX_SKIP_NX_CACHE === 'true' ||
@@ -361,17 +387,20 @@ async function runCommand(projectsToRun, currentProjectGraph, { nxJson }, nxArgs
     });
     return status;
 }
-async function runCommandForTasks(projectsToRun, currentProjectGraph, { nxJson }, nxArgs, overrides, initiatingProject, extraTargetDependencies, extraOptions) {
+async function runTasksForCommand(taskSelection, currentProjectGraph, { nxJson }, nxArgs, overrides, initiatingProject, extraTargetDependencies, extraOptions) {
     // Kick off the license lookup in the background so it overlaps with task
     // execution. The log itself is deferred to the print site below so it
     // never lands in the middle of task output.
     const nxKeyPromise = (0, nx_key_1.getNxKeyInformation)().catch(() => null);
-    const projectNames = projectsToRun.map((t) => t.name);
-    const projectNameSet = new Set(projectNames);
-    const { projectGraph, taskGraph } = await ensureWorkspaceIsInSyncAndGetGraphs(currentProjectGraph, nxJson, projectNames, nxArgs, overrides, extraTargetDependencies, extraOptions);
+    const { projectGraph, taskGraph } = await ensureWorkspaceIsInSyncAndGetGraphs(currentProjectGraph, nxJson, nxArgs, overrides, extraTargetDependencies, extraOptions, taskSelection);
     const tasks = Object.values(taskGraph.tasks);
-    const initiatingTasks = tasks.filter((t) => projectNameSet.has(t.target.project) &&
-        nxArgs.targets.includes(t.target.target));
+    // A sync generator can remove a selected task, so absent ids are skipped.
+    const initiatingTasks = taskSelection.initiatingTaskIds
+        .map((id) => taskGraph.tasks[id])
+        .filter(Boolean);
+    const projectNames = [
+        ...new Set(initiatingTasks.map((t) => t.target.project)),
+    ];
     const { lifeCycle, renderIsDone, printSummary, restoreTerminal } = await getTerminalOutputLifeCycle(initiatingProject, initiatingTasks, projectNames, tasks, taskGraph, nxArgs, nxJson, overrides);
     try {
         const taskResults = await invokeTasksRunner({
@@ -384,6 +413,8 @@ async function runCommandForTasks(projectsToRun, currentProjectGraph, { nxJson }
             loadDotEnvFiles: extraOptions.loadDotEnvFiles,
             initiatingProject,
             initiatingTasks,
+            planningContext: taskSelection.planningContext,
+            ultracacheConfigurationOutcome: taskSelection.ultracacheConfigurationOutcome,
         });
         await renderIsDone.finally(() => restoreTerminal?.());
         if (printSummary) {
@@ -411,6 +442,9 @@ async function runCommandForTasks(projectsToRun, currentProjectGraph, { nxJson }
 }
 async function printConfigureAiAgentsDisclaimer() {
     try {
+        if ((0, is_ci_1.isCI)()) {
+            return;
+        }
         if (!client_1.daemonClient.enabled() || !(await client_1.daemonClient.isServerAvailable())) {
             return;
         }
@@ -437,8 +471,8 @@ function didCommandComplete(tasks, taskResults) {
     // Any stopped task means the run was interrupted
     return !Object.values(taskResults).some((r) => r.status === 'stopped');
 }
-async function ensureWorkspaceIsInSyncAndGetGraphs(projectGraph, nxJson, projectNames, nxArgs, overrides, extraTargetDependencies, extraOptions) {
-    let taskGraph = createTaskGraphAndRunValidations(projectGraph, extraTargetDependencies ?? {}, projectNames, nxArgs, overrides, extraOptions);
+async function ensureWorkspaceIsInSyncAndGetGraphs(projectGraph, nxJson, nxArgs, overrides, extraTargetDependencies, extraOptions, taskSelection) {
+    let taskGraph = runValidations(projectGraph, taskSelection.taskGraph, nxArgs);
     if (nxArgs.skipSync || (0, is_ci_1.isCI)()) {
         return { projectGraph, taskGraph };
     }
@@ -553,9 +587,21 @@ async function ensureWorkspaceIsInSyncAndGetGraphs(projectGraph, nxJson, project
             });
             await confirmRunningTasksWithSyncFailures();
         }
-        // Re-create project graph and task graph
+        // Rebuild rather than carry: a sync generator may remove tasks or move inferred
+        // outputs, so the old graph and planning context are stale.
+        taskSelection.planningContext = undefined;
+        const projectNames = [
+            ...new Set(taskSelection.initiatingTaskIds
+                .filter((id) => taskGraph.tasks[id])
+                .map((id) => taskGraph.tasks[id].target.project)),
+        ];
         projectGraph = await (0, project_graph_1.createProjectGraphAsync)();
-        taskGraph = createTaskGraphAndRunValidations(projectGraph, extraTargetDependencies ?? {}, projectNames, nxArgs, overrides, extraOptions);
+        const rebuilt = selectTasksForProjects(projectGraph, projectNames, nxArgs, overrides, extraTargetDependencies ?? {}, extraOptions.excludeTaskDependencies).taskGraph;
+        taskGraph = runValidations(projectGraph, 
+        // Before validation, so a cycle or atomizer error names what will actually run.
+        taskSelection.taskIds
+            ? (0, utils_1.pruneToSelectedTasks)(rebuilt, taskSelection.taskIds)
+            : rebuilt, nxArgs);
         const successTitle = anySyncGeneratorsFailed
             ? // the identified changes were synced successfully, but the workspace
                 // is still not up to date, which we'll mention next
@@ -641,12 +687,12 @@ function setEnvVarsBasedOnArgs(nxArgs, loadDotEnvFiles) {
     // 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' ||
+    if (nxArgs.specifiedOutputStyle == 'stream' ||
         (batchMode && !(0, output_1.isLogGroupingEnabled)())) {
         process.env.NX_STREAM_OUTPUT = 'true';
         process.env.NX_PREFIX_OUTPUT = 'true';
     }
-    if (nxArgs.outputStyle == 'stream-without-prefixes') {
+    if (nxArgs.specifiedOutputStyle == 'stream-without-prefixes') {
         process.env.NX_STREAM_OUTPUT = 'true';
         process.env.NX_PREFIX_OUTPUT = 'false';
     }
@@ -659,16 +705,22 @@ function setEnvVarsBasedOnArgs(nxArgs, loadDotEnvFiles) {
         process.env.NX_LOAD_DOT_ENV_FILES = 'true';
     }
 }
-async function invokeTasksRunner({ tasks, projectGraph, taskGraph, lifeCycle, nxJson, nxArgs, loadDotEnvFiles, initiatingProject, initiatingTasks, }) {
+async function invokeTasksRunner({ tasks, projectGraph, taskGraph, lifeCycle, nxJson, nxArgs, loadDotEnvFiles, initiatingProject, initiatingTasks, planningContext, ultracacheConfigurationOutcome: loadedUltracacheConfigurationOutcome, }) {
     setEnvVarsBasedOnArgs(nxArgs, loadDotEnvFiles);
     // this needs to be done before we start to run the tasks
     const taskDetails = (0, hash_task_1.getTaskDetails)();
     const { tasksRunner, runnerOptions } = getRunner(nxArgs, nxJson);
-    let hasher = (0, create_task_hasher_1.createTaskHasher)(projectGraph, nxJson, runnerOptions);
+    // Must precede hashing: the Ultracache configurations are a source for task hashes.
+    const ultracacheConfigurationOutcome = loadedUltracacheConfigurationOutcome !== undefined
+        ? loadedUltracacheConfigurationOutcome
+        : await (0, store_1.loadUltracacheConfigurationsForRun)(nxJson, runnerOptions);
+    const ultracacheConfigurations = (0, store_1.configurationsOf)(ultracacheConfigurationOutcome);
+    let hasher = (0, create_task_hasher_1.createTaskHasher)(projectGraph, nxJson, runnerOptions, ultracacheConfigurations, planningContext);
     // this is used for two reasons: to fetch all remote cache hits AND
     // to submit everything that is known in advance to Nx Cloud to run in
     // a distributed fashion
-    await (0, hash_task_1.hashTasksThatDoNotDependOnOutputsOfOtherTasks)(hasher, projectGraph, taskGraph, nxJson, taskDetails);
+    const deferredTaskIds = await (0, hash_task_1.hashTasksThatDoNotDependOnOutputsOfOtherTasks)(hasher, projectGraph, taskGraph, nxJson, taskDetails, ultracacheConfigurations);
+    reportUltracacheConfigurations(ultracacheConfigurationOutcome, projectGraph, taskGraph, nxArgs);
     const taskResultsLifecycle = new task_results_life_cycle_1.TaskResultsLifeCycle();
     const compositedLifeCycle = new life_cycle_1.CompositeLifeCycle([
         ...constructLifeCycles(lifeCycle, taskGraph, nxJson, nxArgs.skipNxCache),
@@ -733,8 +785,12 @@ async function invokeTasksRunner({ tasks, projectGraph, taskGraph, lifeCycle, nx
                 // per-task-env shape and normalizes internally.
                 return hasher.hashTasks(tasks, taskGraph_, envOrPerTaskEnvs);
             },
+            hashTasksUpfront(tasks, taskGraph_, perTaskEnvs) {
+                return hasher.hashTasksUpfront(tasks, taskGraph_, perTaskEnvs);
+            },
         },
         daemon: client_1.daemonClient,
+        deferredTaskIds,
     });
     if (promiseOrObservable.subscribe) {
         promiseOrObservable = convertObservableToPromise(promiseOrObservable);
@@ -789,6 +845,7 @@ function shouldUseDynamicLifeCycle(tasks, options, outputStyle) {
     if ((0, is_ci_1.isCI)())
         return false;
     if ((0, output_1.isStaticOutputStyle)(outputStyle) ||
+        outputStyle === 'summary' ||
         outputStyle === 'stream' ||
         outputStyle === 'stream-without-prefixes')
         return false;
@@ -811,6 +868,25 @@ function loadTasksRunner(modulePath) {
         throw e;
     }
 }
+function reportUltracacheConfigurations(outcome, projectGraph, taskGraph, nxArgs) {
+    if (!outcome || outcome.status === 'skipped')
+        return;
+    if (!nxArgs.verbose && process.env.NX_VERBOSE_LOGGING !== 'true')
+        return;
+    const summary = (0, report_1.formatUltracacheSummary)((0, overrides_1.buildUltracacheOverrides)(projectGraph, taskGraph, outcome.configurations), outcome.status);
+    output_1.output.note({ title: summary.line, bodyLines: summary.bodyLines });
+}
+/**
+ * What affected task selection reads from the runner options, so it plans as
+ * the run hashes. The Ultracache configurations are loaded once, for selection and the run.
+ */
+async function runnerInputsForSelection(nxArgs, nxJson) {
+    const { runnerOptions } = getRunner(nxArgs, nxJson);
+    return {
+        ultracacheConfigurationOutcome: await (0, store_1.loadUltracacheConfigurationsForRun)(nxJson, runnerOptions),
+        selectivelyHashTsConfig: runnerOptions?.selectivelyHashTsConfig ?? false,
+    };
+}
 function getRunner(nxArgs, nxJson) {
     let runner = nxArgs.runner;
     runner = runner ?? 'default';