nx 23.3.0-beta.5 → 23.3.0-beta.7

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);
                     }
@@ -180,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,
@@ -208,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) {
@@ -220,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/forked-process-task-runner.js

@@ -144,7 +144,7 @@ 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,
@@ -181,7 +181,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);
             }
             // Send message to run the executor
             p.send({
@@ -224,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);

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 { IoSnapshots } 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 `importIoSnapshots`; omitted hashes natively. */
+ioSnapshots?: IoSnapshots): 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 `importIoSnapshots`; omitted hashes natively. */
+ioSnapshots?: IoSnapshots): Promise<Record<string, Promise<RunningTask>>>;

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

@@ -8,10 +8,11 @@ const dotenv_1 = require("../utils/dotenv");
 const life_cycle_1 = require("./life-cycle");
 const task_orchestrator_1 = require("./task-orchestrator");
 const create_task_hasher_1 = require("../hasher/create-task-hasher");
+const outputs_1 = require("../io-snapshots/outputs");
 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, ioSnapshots) {
     (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 +22,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,6 +37,13 @@ async function createOrchestrator(tasks, projectGraph, fullTaskGraph, nxJson, li
             return acc;
         }, {}),
     };
+    // As in run-command, unhashed tasks hash from the caller's set. Applying is
+    // idempotent, so both graphs may share the same Task objects.
+    if (ioSnapshots) {
+        (0, outputs_1.applyIoSnapshotOutputs)(projectGraph, fullTaskGraph, ioSnapshots);
+        (0, outputs_1.applyIoSnapshotOutputs)(projectGraph, taskGraph, ioSnapshots);
+    }
+    const hasher = (0, create_task_hasher_1.createTaskHasher)(projectGraph, nxJson, options, ioSnapshots);
     const nxArgs = {
         ...options,
         parallel: tasks.length,
@@ -57,8 +64,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 `importIoSnapshots`; omitted hashes natively. */
+ioSnapshots) {
+    const orchestrator = await createOrchestrator(tasks, projectGraph, fullTaskGraph, nxJson, lifeCycle, ioSnapshots);
     let groupId = 0;
     let nextBatch = orchestrator.nextBatch();
     const batchResults = [];
@@ -96,8 +105,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 `importIoSnapshots`; omitted hashes natively. */
+ioSnapshots) {
+    const orchestrator = await createOrchestrator(tasks, projectGraph, fullTaskGraph, nxJson, lifeCycle, ioSnapshots);
     const runningTasks = tasks.reduce((current, task, index) => {
         current[task.id] = orchestrator.startContinuousTask(task, index);
         return current;

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 IoSnapshotOutcome } from '../io-snapshots/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 I/O snapshot set selection planned with; the run hashes with the same one. */
+    ioSnapshotOutcome?: IoSnapshotOutcome | 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, ioSnapshotOutcome: loadedIoSnapshotOutcome, }: {
     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. */
+    ioSnapshotOutcome?: IoSnapshotOutcome | 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 snapshot set is loaded once, for selection and the run.
+ */
+export declare function runnerInputsForSelection(nxArgs: NxArgs, nxJson: NxJsonConfiguration): Promise<{
+    ioSnapshotOutcome: IoSnapshotOutcome | 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,10 @@ 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 outputs_1 = require("../io-snapshots/outputs");
+const overrides_1 = require("../io-snapshots/overrides");
+const report_1 = require("../io-snapshots/report");
+const store_1 = require("../io-snapshots/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");
@@ -305,8 +311,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) {
@@ -332,7 +352,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)({
@@ -342,7 +362,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' ||
@@ -368,17 +388,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({
@@ -391,6 +414,8 @@ async function runCommandForTasks(projectsToRun, currentProjectGraph, { nxJson }
             loadDotEnvFiles: extraOptions.loadDotEnvFiles,
             initiatingProject,
             initiatingTasks,
+            planningContext: taskSelection.planningContext,
+            ioSnapshotOutcome: taskSelection.ioSnapshotOutcome,
         });
         await renderIsDone.finally(() => restoreTerminal?.());
         if (printSummary) {
@@ -447,8 +472,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 };
     }
@@ -563,9 +588,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
@@ -669,16 +706,26 @@ 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, ioSnapshotOutcome: loadedIoSnapshotOutcome, }) {
     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 set is the snapshot source for task hashes,
+    // and observed outputs join the task outputs the hasher and cache see.
+    const ioSnapshotOutcome = loadedIoSnapshotOutcome !== undefined
+        ? loadedIoSnapshotOutcome
+        : await (0, store_1.loadIoSnapshotsForRun)(nxJson, runnerOptions);
+    const ioSnapshots = (0, store_1.snapshotsOf)(ioSnapshotOutcome);
+    if (ioSnapshots) {
+        (0, outputs_1.applyIoSnapshotOutputs)(projectGraph, taskGraph, ioSnapshots);
+    }
+    let hasher = (0, create_task_hasher_1.createTaskHasher)(projectGraph, nxJson, runnerOptions, ioSnapshots, 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);
+    await (0, hash_task_1.hashTasksThatDoNotDependOnOutputsOfOtherTasks)(hasher, projectGraph, taskGraph, nxJson, taskDetails, ioSnapshots);
+    reportIoSnapshots(ioSnapshotOutcome, 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),
@@ -825,6 +872,25 @@ function loadTasksRunner(modulePath) {
         throw e;
     }
 }
+function reportIoSnapshots(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.formatIoSnapshotSummary)((0, overrides_1.buildIoSnapshotOverrides)(projectGraph, taskGraph, outcome.snapshots), 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 snapshot set is loaded once, for selection and the run.
+ */
+async function runnerInputsForSelection(nxArgs, nxJson) {
+    const { runnerOptions } = getRunner(nxArgs, nxJson);
+    return {
+        ioSnapshotOutcome: await (0, store_1.loadIoSnapshotsForRun)(nxJson, runnerOptions),
+        selectivelyHashTsConfig: runnerOptions?.selectivelyHashTsConfig ?? false,
+    };
+}
 function getRunner(nxArgs, nxJson) {
     let runner = nxArgs.runner;
     runner = runner ?? 'default';

package/dist/src/tasks-runner/task-io-service.d.ts

@@ -1,3 +1,4 @@
+import type { Task } from '../config/task-graph';
 /**
  * Maps taskId -> PID. Note that this only Returns
  * the PID that the main task process is running under,
@@ -89,8 +90,15 @@ export declare function getTaskIOService(): TaskIOService;
 /**
  * Register a task process start with both IO and metrics services.
  * This is the standard way to notify the system that a task process has started.
- * Both services need to be notified together - TaskIOService for external subscribers
- * and ProcessMetricsService for native resource monitoring.
+ *
+ * A target on `ultracache: { mode: 'off' }` reports no PID, which suppresses IO
+ * tracing and therefore its report. Every other mode records — they differ in
+ * what is done with the recording, not in whether it is taken. Metrics are
+ * registered either way: the opt-out covers reporting, not the process
+ * management that cleanup and orphan reaping depend on.
+ *
+ * Narrower than a whole `Task` because `run-commands` can synthesize an id for
+ * a task that is not in any graph.
  */
-export declare function registerTaskProcessStart(taskId: string, pid: number): void;
+export declare function registerTaskProcessStart(task: Pick<Task, 'id' | 'ultracache'>, pid: number): void;
 export {};

package/dist/src/tasks-runner/task-io-service.js

@@ -113,10 +113,19 @@ function getTaskIOService() {
 /**
  * Register a task process start with both IO and metrics services.
  * This is the standard way to notify the system that a task process has started.
- * Both services need to be notified together - TaskIOService for external subscribers
- * and ProcessMetricsService for native resource monitoring.
+ *
+ * A target on `ultracache: { mode: 'off' }` reports no PID, which suppresses IO
+ * tracing and therefore its report. Every other mode records — they differ in
+ * what is done with the recording, not in whether it is taken. Metrics are
+ * registered either way: the opt-out covers reporting, not the process
+ * management that cleanup and orphan reaping depend on.
+ *
+ * Narrower than a whole `Task` because `run-commands` can synthesize an id for
+ * a task that is not in any graph.
  */
-function registerTaskProcessStart(taskId, pid) {
-    getTaskIOService().notifyPidUpdate({ taskId, pid });
-    (0, process_metrics_service_1.getProcessMetricsService)().registerTaskProcess(taskId, pid);
+function registerTaskProcessStart(task, pid) {
+    if (task.ultracache?.mode !== 'off') {
+        getTaskIOService().notifyPidUpdate({ taskId: task.id, pid });
+    }
+    (0, process_metrics_service_1.getProcessMetricsService)().registerTaskProcess(task.id, pid);
 }

package/dist/src/tasks-runner/task-orchestrator.js

@@ -1019,7 +1019,7 @@ class TaskOrchestrator {
                 };
                 const runningTask = await (0, run_commands_impl_1.runCommands)(runCommandsOptions, {
                     root: workspace_root_1.workspaceRoot, // only root is needed in runCommands
-                }, task.id);
+                }, task);
                 this.runningRunCommandsTasks.set(task.id, runningTask);
                 runningTask.onExit(() => {
                     this.runningRunCommandsTasks.delete(task.id);

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

@@ -49,6 +49,11 @@ export declare function getExecutorForTask(task: Task, projects: Record<string,
     isNxExecutor: boolean;
 };
 export declare function getCustomHasher(task: Task, projects: Record<string, ProjectConfiguration>): CustomHasher | null;
+/**
+ * `taskGraph` pruned to `required`, which must already hold its dependencies.
+ * Unknown ids are ignored: a sync generator can remove a task after selection.
+ */
+export declare function pruneToSelectedTasks(taskGraph: TaskGraph, required: Iterable<string>): TaskGraph;
 export declare function removeTasksFromTaskGraph(graph: TaskGraph, ids: string[]): TaskGraph;
 export declare function calculateReverseDeps(taskGraph: TaskGraph): Record<string, string[]>;
 export declare function getCliPath(): string;

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

@@ -17,6 +17,7 @@ exports.getExecutorNameForTask = getExecutorNameForTask;
 exports.expandInitiatingTasksThroughNoop = expandInitiatingTasksThroughNoop;
 exports.getExecutorForTask = getExecutorForTask;
 exports.getCustomHasher = getCustomHasher;
+exports.pruneToSelectedTasks = pruneToSelectedTasks;
 exports.removeTasksFromTaskGraph = removeTasksFromTaskGraph;
 exports.calculateReverseDeps = calculateReverseDeps;
 exports.getCliPath = getCliPath;
@@ -344,6 +345,14 @@ function getCustomHasher(task, projects) {
     const factory = getExecutorForTask(task, projects).hasherFactory;
     return factory ? factory() : null;
 }
+/**
+ * `taskGraph` pruned to `required`, which must already hold its dependencies.
+ * Unknown ids are ignored: a sync generator can remove a task after selection.
+ */
+function pruneToSelectedTasks(taskGraph, required) {
+    const keep = new Set(required);
+    return removeTasksFromTaskGraph(taskGraph, Object.keys(taskGraph.tasks).filter((id) => !keep.has(id)));
+}
 function removeTasksFromTaskGraph(graph, ids) {
     const newGraph = removeIdsFromTaskGraph(graph, ids, graph.tasks);
     return {

package/dist/src/utils/db-connection.d.ts

@@ -1,4 +1,5 @@
 import { ExternalObject } from '../native';
+export declare function sharedWorkspaceDataDirectory(root: string): string;
 export declare function getDbConnection(opts?: {
     directory?: string;
     dbName?: string;

package/dist/src/utils/db-connection.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.sharedWorkspaceDataDirectory = sharedWorkspaceDataDirectory;
 exports.getDbConnection = getDbConnection;
 exports.getLocalDbConnection = getLocalDbConnection;
 const native_1 = require("../native");

package/dist/src/utils/json-diff.d.ts

@@ -13,6 +13,8 @@ export interface JsonChange extends Change {
     };
 }
 export declare function isJsonChange(change: Change): change is JsonChange;
+/**
+ * The changes from `lhs` to `rhs`: every path whose value was deleted or
+ * modified, containers included, then every added path.
+ */
 export declare function jsonDiff(lhs: any, rhs: any): JsonChange[];
-export declare function walkJsonTree(json: any, currPath: string[], visitor: (path: string[], value: any) => boolean): void;
-export declare function deepEquals(a: any, b: any): boolean;