diff --git a/src/CloudNimble.DotNetDocs.Mintlify/MintlifyRenderer.cs b/src/CloudNimble.DotNetDocs.Mintlify/MintlifyRenderer.cs
index 431e563..8b6902f 100644
--- a/src/CloudNimble.DotNetDocs.Mintlify/MintlifyRenderer.cs
+++ b/src/CloudNimble.DotNetDocs.Mintlify/MintlifyRenderer.cs
@@ -76,7 +76,7 @@ public async Task RenderAsync(DocAssembly model)
             ArgumentNullException.ThrowIfNull(model);
 
             var apiOutputPath = Path.Combine(Context.DocumentationRootPath, Context.ApiReferencePath);
-            Console.WriteLine($"📝 Rendering documentation to: {apiOutputPath}");
+            // Console.WriteLine($"📝 Rendering documentation to: {apiOutputPath}");
 
             // Initialize DocsJsonManager if enabled (only on first call)
             DocsJsonConfig? docsConfig = null;
@@ -1501,7 +1501,7 @@ private async Task GenerateNamespacePlaceholdersAsync(DocNamespace ns, string co
             var namespacePath = Context.GetNamespaceFolderPath(ns.Name ?? "global");
             var namespaceDir = Path.Combine(conceptualPath, namespacePath);
 
-            Console.WriteLine($"📝 Generating namespace placeholders for: {ns.Name} at {namespaceDir}");
+            // Console.WriteLine($"📝 Generating namespace placeholders for: {ns.Name} at {namespaceDir}");
             Directory.CreateDirectory(namespaceDir);
 
             // Generate individual placeholder files
diff --git a/src/CloudNimble.DotNetDocs.Sdk.Tasks/CloudNimble.DotNetDocs.Sdk.Tasks.csproj b/src/CloudNimble.DotNetDocs.Sdk.Tasks/CloudNimble.DotNetDocs.Sdk.Tasks.csproj
deleted file mode 100644
index 72ebe93..0000000
--- a/src/CloudNimble.DotNetDocs.Sdk.Tasks/CloudNimble.DotNetDocs.Sdk.Tasks.csproj
+++ /dev/null
@@ -1,54 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-
-    <PropertyGroup>
-        <!-- Multi-target for compatibility with different MSBuild runtimes -->
-        <TargetFrameworks>net10.0;net9.0;net8.0;net472</TargetFrameworks>
-        <GenerateDocumentationFile>false</GenerateDocumentationFile>
-        <Description>MSBuild tasks for CloudNimble.DotNetDocs.Sdk</Description>
-        
-        <!-- This is a task library, not a package -->
-        <IsPackable>false</IsPackable>
-        <GeneratePackageOnBuild>false</GeneratePackageOnBuild>
-        
-        <!-- Suppress warnings -->
-        <NoWarn>$(NoWarn);CS2008;NU1701</NoWarn>
-        
-        <!-- Copy dependencies for task execution -->
-        <CopyLocalLockFileAssemblies>true</CopyLocalLockFileAssemblies>
-    </PropertyGroup>
-
-    <ItemGroup>
-        <!-- MSBuild task dependencies -->
-        <PackageReference Include="EasyAF.MSBuild" Version="3.*-*" />
-        <PackageReference Include="Microsoft.Build.Framework" Version="17.*" PrivateAssets="all" />
-        <PackageReference Include="Microsoft.Build.Utilities.Core" Version="17.*" PrivateAssets="all" ExcludeAssets="runtime" />
-        <PackageReference Include="System.Collections.Immutable" Version="9.*" PrivateAssets="all" />
-        
-        <!-- Microsoft.CodeAnalysis.CSharp.Workspaces needs to be available for the task -->
-        <PackageReference Include="Microsoft.CodeAnalysis.CSharp.Workspaces" Version="4.*" />
-    </ItemGroup>
-
-    <!-- Framework-specific dependencies -->
-    <ItemGroup Condition="'$(TargetFramework)' == 'net10.0'">
-        <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="10.*-*" />
-    </ItemGroup>
-
-    <ItemGroup Condition="'$(TargetFramework)' == 'net9.0'">
-        <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="9.*" />
-    </ItemGroup>
-
-    <ItemGroup Condition="'$(TargetFramework)' == 'net8.0'">
-        <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="9.*" />
-    </ItemGroup>
-
-    <ItemGroup Condition="'$(TargetFramework)' == 'net472'">
-        <PackageReference Include="System.ValueTuple" Version="4.*" />
-    </ItemGroup>
-
-    <!-- Project references for .NET Core/5+ only -->
-    <ItemGroup Condition="'$(TargetFramework)' != 'net472'">
-        <ProjectReference Include="..\CloudNimble.DotNetDocs.Core\CloudNimble.DotNetDocs.Core.csproj" />
-        <ProjectReference Include="..\CloudNimble.DotNetDocs.Mintlify\CloudNimble.DotNetDocs.Mintlify.csproj" />
-    </ItemGroup>
-
-</Project>
diff --git a/src/CloudNimble.DotNetDocs.Sdk.Tasks/DiscoverDocumentedProjectsTask.cs b/src/CloudNimble.DotNetDocs.Sdk.Tasks/DiscoverDocumentedProjectsTask.cs
deleted file mode 100644
index db8326e..0000000
--- a/src/CloudNimble.DotNetDocs.Sdk.Tasks/DiscoverDocumentedProjectsTask.cs
+++ /dev/null
@@ -1,302 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using CloudNimble.EasyAF.Core;
-using Microsoft.Build.Evaluation;
-using Microsoft.Build.Framework;
-using Microsoft.Build.Utilities;
-
-namespace CloudNimble.DotNetDocs.Sdk.Tasks
-{
-
-    /// <summary>
-    /// MSBuild task that discovers which projects in a solution should be documented based on their MSBuild properties.
-    /// </summary>
-    public class DiscoverDocumentedProjectsTask : Task
-    {
-
-        #region Fields
-
-        internal Dictionary<string, bool> _propertiesToEvaluate = new()
-        {
-            { "IsTestProject", false }, // Exclude test projects
-            { "IsPackable", true }, // Include only packable projects (default is true)
-            { "ExcludeFromDocumentation", false } // Exclude projects explicitly marked to be excluded
-        };
-
-        #endregion
-
-        #region Properties
-
-        /// <summary>
-        /// Gets or sets the solution directory to search for projects.
-        /// </summary>
-        [Required]
-        public string SolutionDir { get; set; } = string.Empty;
-
-        /// <summary>
-        /// Gets or sets the configuration to use when evaluating projects.
-        /// </summary>
-        public string Configuration { get; set; } = "Release";
-
-        /// <summary>
-        /// Gets or sets the target framework to use when evaluating projects.
-        /// </summary>
-        public string TargetFramework { get; set; } = "net8.0";
-
-        /// <summary>
-        /// Gets or sets the exclude patterns for projects that should not be documented.
-        /// </summary>
-        public string[]? ExcludePatterns { get; set; }
-
-        /// <summary>
-        /// Gets or sets the discovered projects that should be documented.
-        /// </summary>
-        [Output]
-        public ITaskItem[] DocumentedProjects { get; set; } = [];
-
-        #endregion
-
-        #region Public Methods
-
-        /// <summary>
-        /// Executes the task to discover documented projects.
-        /// </summary>
-        /// <returns>true if the task executed successfully; otherwise, false.</returns>
-        public override bool Execute()
-        {
-            try
-            {
-                Log.LogMessage(MessageImportance.High, $"🔍 Discovering documented projects in {SolutionDir}...");
-
-                var documentedProjects = new List<ITaskItem>();
-
-                // Search for all .NET project file types and filter out excluded patterns
-                var projectExtensions = new[] { "*.csproj", "*.vbproj", "*.fsproj" };
-                var projectFiles = projectExtensions
-                    .SelectMany(ext => Directory.GetFiles(SolutionDir, ext, SearchOption.AllDirectories))
-                    .Where(file => ExcludePatterns is null || !ExcludePatterns.Any(pattern =>
-                        Path.GetFileNameWithoutExtension(file).Contains(pattern.Replace("*", ""), StringComparison.OrdinalIgnoreCase)))
-                    .ToArray();
-
-                var projectCollection = new ProjectCollection();
-
-                // Set up global properties for evaluation
-                var globalProperties = new Dictionary<string, string>
-                {
-                    { "Configuration", Configuration }
-                };
-
-                foreach (var projectFile in projectFiles)
-                {
-                    var projectName = Path.GetFileNameWithoutExtension(projectFile);
-
-                    try
-                    {
-                        // Create an evaluated project to get computed property values
-                        var project = new Project(projectFile, globalProperties, null, projectCollection);
-
-                        try
-                        {
-
-                            bool shouldSkip = false;
-                            foreach (var prop in _propertiesToEvaluate)
-                            {
-                                var propValue = project.GetPropertyValue(prop.Key);
-                                if (string.Equals(propValue, "true", StringComparison.OrdinalIgnoreCase) != prop.Value)
-                                {
-                                    Log.LogMessage(MessageImportance.Low, $"   ⏭️ Skipping project {projectName} due to property {prop.Key}={propValue}");
-                                    shouldSkip = true;
-                                    break;
-                                }
-                            }
-                            if (shouldSkip)
-                            {
-                                continue; // Skip to next project
-                            }
-
-                            // This is a project we should document
-                            var item = new TaskItem(projectFile);
-
-                            // Set metadata from the evaluated project
-                            var assemblyName = project.GetPropertyValue("AssemblyName");
-                            if (string.IsNullOrEmpty(assemblyName))
-                            {
-                                assemblyName = projectName;
-                            }
-
-                            var targetFramework = project.GetPropertyValue("TargetFramework");
-                            if (string.IsNullOrEmpty(targetFramework))
-                            {
-                                // For multi-targeted projects, use TargetFrameworks and pick the first one
-                                var targetFrameworks = project.GetPropertyValue("TargetFrameworks");
-                                if (!string.IsNullOrEmpty(targetFrameworks))
-                                {
-                                    targetFramework = targetFrameworks.Split(';')[0].Trim();
-                                }
-                                else
-                                {
-                                    targetFramework = TargetFramework; // Use default
-                                }
-                            }
-
-                            item.SetMetadata("AssemblyName", assemblyName);
-                            item.SetMetadata("OutputPath", $"bin\\{Configuration}");
-                            item.SetMetadata("TargetFramework", targetFramework);
-                            item.SetMetadata("TargetPath", $"bin\\{Configuration}\\{targetFramework}\\{assemblyName}.dll");
-
-                            documentedProjects.Add(item);
-                            Log.LogMessage(MessageImportance.High, $"   ✅ Found packable project: {projectName}");
-                        }
-                        finally
-                        {
-                            // Always unload the project to free resources
-                            projectCollection.UnloadProject(project);
-                        }
-                    }
-                    catch (Exception ex)
-                    {
-                        Log.LogWarning($"Could not evaluate project {projectFile}: {ex.Message}");
-                    }
-                }
-
-                // Clean up the project collection
-                projectCollection.UnloadAllProjects();
-
-                DocumentedProjects = [.. documentedProjects];
-                Log.LogMessage(MessageImportance.High, $"📊 Found {DocumentedProjects.Length} documented projects");
-
-                return true;
-            }
-            catch (Exception ex)
-            {
-                Log.LogError($"Failed to discover documented projects: {ex.Message}");
-                return false;
-            }
-        }
-
-        #endregion
-
-        #region Internal Methods
-
-        /// <summary>
-        /// Discovers project files in the specified directory.
-        /// </summary>
-        /// <param name="solutionDir">The solution directory to search.</param>
-        /// <param name="excludePatterns">Patterns to exclude from discovery.</param>
-        /// <returns>Array of discovered project file paths.</returns>
-        internal string[] DiscoverProjectFiles(string solutionDir, string[]? excludePatterns)
-        {
-            Ensure.ArgumentNotNullOrWhiteSpace(solutionDir, nameof(solutionDir));
-
-            var projectExtensions = new[] { "*.csproj", "*.vbproj", "*.fsproj" };
-            return projectExtensions
-                .SelectMany(ext => Directory.GetFiles(solutionDir, ext, SearchOption.AllDirectories))
-                .Where(file => ShouldIncludeProject(file, excludePatterns))
-                .ToArray();
-        }
-
-        /// <summary>
-        /// Determines if a project file should be included based on exclude patterns.
-        /// </summary>
-        /// <param name="projectFilePath">The project file path.</param>
-        /// <param name="excludePatterns">Patterns to exclude.</param>
-        /// <returns>true if the project should be included; otherwise, false.</returns>
-        internal bool ShouldIncludeProject(string projectFilePath, string[]? excludePatterns)
-        {
-            Ensure.ArgumentNotNullOrWhiteSpace(projectFilePath, nameof(projectFilePath));
-
-            if (excludePatterns is null || excludePatterns.Length == 0)
-            {
-                return true;
-            }
-
-            var fileName = Path.GetFileNameWithoutExtension(projectFilePath);
-            return !excludePatterns.Any(pattern =>
-                fileName.Contains(pattern.Replace("*", ""), StringComparison.OrdinalIgnoreCase));
-        }
-
-        /// <summary>
-        /// Evaluates if a project should be documented based on its properties.
-        /// </summary>
-        /// <param name="project">The MSBuild project to evaluate.</param>
-        /// <returns>true if the project should be documented; otherwise, false.</returns>
-        internal bool ShouldDocumentProject(Project project)
-        {
-            Ensure.ArgumentNotNull(project, nameof(project));
-
-            foreach (var prop in _propertiesToEvaluate)
-            {
-                var propValue = project.GetPropertyValue(prop.Key);
-                if (string.Equals(propValue, "true", StringComparison.OrdinalIgnoreCase) != prop.Value)
-                {
-                    return false;
-                }
-            }
-
-            return true;
-        }
-
-        /// <summary>
-        /// Creates a task item with metadata for a documented project.
-        /// </summary>
-        /// <param name="project">The MSBuild project.</param>
-        /// <param name="projectFilePath">The project file path.</param>
-        /// <returns>A task item with appropriate metadata.</returns>
-        internal ITaskItem CreateProjectTaskItem(Project project, string projectFilePath)
-        {
-            Ensure.ArgumentNotNull(project, nameof(project));
-            Ensure.ArgumentNotNullOrWhiteSpace(projectFilePath, nameof(projectFilePath));
-
-            var projectName = Path.GetFileNameWithoutExtension(projectFilePath);
-            var item = new TaskItem(projectFilePath);
-
-            // Set metadata from the evaluated project
-            var assemblyName = project.GetPropertyValue("AssemblyName");
-            if (string.IsNullOrEmpty(assemblyName))
-            {
-                assemblyName = projectName;
-            }
-
-            var targetFramework = GetProjectTargetFramework(project);
-
-            item.SetMetadata("AssemblyName", assemblyName);
-            item.SetMetadata("OutputPath", $"bin\\{Configuration}");
-            item.SetMetadata("TargetFramework", targetFramework);
-            item.SetMetadata("TargetPath", $"bin\\{Configuration}\\{targetFramework}\\{assemblyName}.dll");
-
-            return item;
-        }
-
-        /// <summary>
-        /// Gets the target framework for a project, handling both single and multi-targeted projects.
-        /// </summary>
-        /// <param name="project">The MSBuild project.</param>
-        /// <returns>The target framework string.</returns>
-        internal string GetProjectTargetFramework(Project project)
-        {
-            Ensure.ArgumentNotNull(project, nameof(project));
-
-            var targetFramework = project.GetPropertyValue("TargetFramework");
-            if (!string.IsNullOrEmpty(targetFramework))
-            {
-                return targetFramework;
-            }
-
-            // For multi-targeted projects, use TargetFrameworks and pick the first one
-            var targetFrameworks = project.GetPropertyValue("TargetFrameworks");
-            if (!string.IsNullOrEmpty(targetFrameworks))
-            {
-                return targetFrameworks.Split(';')[0].Trim();
-            }
-
-            // Use default
-            return TargetFramework;
-        }
-
-        #endregion
-
-    }
-
-}
\ No newline at end of file
diff --git a/src/CloudNimble.DotNetDocs.Sdk/CloudNimble.DotNetDocs.Sdk.csproj b/src/CloudNimble.DotNetDocs.Sdk/CloudNimble.DotNetDocs.Sdk.csproj
index 2a6f12c..0c2b8ab 100644
--- a/src/CloudNimble.DotNetDocs.Sdk/CloudNimble.DotNetDocs.Sdk.csproj
+++ b/src/CloudNimble.DotNetDocs.Sdk/CloudNimble.DotNetDocs.Sdk.csproj
@@ -1,8 +1,8 @@
-<Project Sdk="Microsoft.Build.NoTargets/3.7.0">
+<Project Sdk="Microsoft.NET.Sdk">
 
     <PropertyGroup>
         <!-- SDK packages don't compile code -->
-        <TargetFramework>netstandard2.0</TargetFramework>
+        <TargetFrameworks>net8.0;net472</TargetFrameworks>
         <GenerateDocumentationFile>false</GenerateDocumentationFile>
         <Description>The MSBuild SDK for documentation projects (.docsproj) that provides a clean way to include documentation in .NET solutions.</Description>
 
@@ -10,6 +10,8 @@
         <DevelopmentDependency>true</DevelopmentDependency>
         <PackageType>MSBuildSdk</PackageType>
         <GeneratePackageOnBuild>true</GeneratePackageOnBuild>
+        <CopyLocalLockFileAssemblies>true</CopyLocalLockFileAssemblies>
+        <IncludeBuildOutput>false</IncludeBuildOutput>
 
         <!-- Suppress warnings about SDK packages -->
         <NoWarn>$(NoWarn);NU5128;CS2008;NU1701;NU5100</NoWarn>
@@ -19,65 +21,55 @@
         
         <!-- Suppress dependencies when packing -->
         <SuppressDependenciesWhenPacking>true</SuppressDependenciesWhenPacking>
+        <TargetsForTfmSpecificContentInPackage>$(TargetsForTfmSpecificContentInPackage);AddPerTFMDocsTasksToPackage</TargetsForTfmSpecificContentInPackage>
     </PropertyGroup>
 
     <ItemGroup>
-        <!-- Include Microsoft.Build.NoTargets for bundling its SDK files -->
-        <PackageReference Include="Microsoft.Build.NoTargets"
-                          Version="3.7.*"
-                          PrivateAssets="all"
-                          GeneratePathProperty="true" />
+        <!-- MSBuild task dependencies -->
+        <PackageReference Include="EasyAF.MSBuild" Version="3.*-*" />
+        <PackageReference Include="Microsoft.Build.Framework" Version="17.*" PrivateAssets="all" />
+        <PackageReference Include="Microsoft.Build.Utilities.Core" Version="17.*" PrivateAssets="all" ExcludeAssets="runtime" />
+        <PackageReference Include="System.Collections.Immutable" Version="9.*" PrivateAssets="all" />
+        
+        <!-- Microsoft.CodeAnalysis.CSharp.Workspaces needs to be available for the task -->
+        <PackageReference Include="Microsoft.CodeAnalysis.CSharp.Workspaces" Version="4.*" />
+    </ItemGroup>
+
+    <ItemGroup Condition="'$(TargetFramework)' == 'net8.0'">
+        <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="9.*" />
+    </ItemGroup>
+
+    <ItemGroup Condition="'$(TargetFramework)' == 'net472'">
+        <PackageReference Include="System.ValueTuple" Version="4.*" />
+    </ItemGroup>
+
+    <!-- Project references for .NET Core/5+ only -->
+    <ItemGroup Condition="'$(TargetFramework)' != 'net472'">
+        <ProjectReference Include="..\CloudNimble.DotNetDocs.Core\CloudNimble.DotNetDocs.Core.csproj" />
+        <ProjectReference Include="..\CloudNimble.DotNetDocs.Mintlify\CloudNimble.DotNetDocs.Mintlify.csproj" />
     </ItemGroup>
 
     <ItemGroup>
         <!-- Pack the SDK files -->
         <None Include="Sdk\**" Pack="true" PackagePath="Sdk" />
         <None Include="build\**" Pack="true" PackagePath="build" />
-        
-        <!-- Include pre-built task assemblies directly (only during packaging) -->
-        <!-- .NET 8.0 tasks -->
-        <None Include="..\CloudNimble.DotNetDocs.Sdk.Tasks\bin\$(Configuration)\net8.0\*.dll"
-              Pack="true"
-              PackagePath="tasks\net8.0"
-              Visible="false" />
-              
-        <!-- .NET 9.0 tasks -->
-        <None Include="..\CloudNimble.DotNetDocs.Sdk.Tasks\bin\$(Configuration)\net9.0\*.dll"
-              Pack="true"
-              PackagePath="tasks\net9.0"
-              Visible="false" />
-              
-        <!-- .NET 10.0 tasks -->
-        <None Include="..\CloudNimble.DotNetDocs.Sdk.Tasks\bin\$(Configuration)\net10.0\*.dll"
-              Pack="true"
-              PackagePath="tasks\net10.0"
-              Visible="false" />
-              
-        <!-- .NET Framework 4.7.2 tasks -->
-        <None Include="..\CloudNimble.DotNetDocs.Sdk.Tasks\bin\$(Configuration)\net472\*.dll"
-              Pack="true"
-              PackagePath="tasks\net472"
-              Visible="false" />
     </ItemGroup>
-    
-    <!-- Build the tasks project before packing this SDK (but not when NoBuild is set) -->
-    <Target Name="BuildTasksProject" BeforeTargets="Pack" Condition="'$(NoBuild)' != 'true'">
-        <MSBuild Projects="..\CloudNimble.DotNetDocs.Sdk.Tasks\CloudNimble.DotNetDocs.Sdk.Tasks.csproj"
-                 Targets="Build"
-                 Properties="Configuration=$(Configuration)" />
-        <Message Text="Built CloudNimble.DotNetDocs.Sdk.Tasks" Importance="high" />
-    </Target>
 
-    <!-- When NoBuild is set, verify task assemblies exist from previous build -->
-    <Target Name="VerifyTaskAssemblies" BeforeTargets="Pack" Condition="'$(NoBuild)' == 'true'">
+    <!-- This is called for each TFM of this project - so we should be able to ask ourselves what our own outputs are -->
+    <Target Name="AddPerTFMDocsTasksToPackage" Returns="@(TfmSpecificPackageFile)" DependsOnTargets="ResolveProjectReferences">
+        <PropertyGroup>
+            <_TargetsForReferenceOutputs>ReferenceCopyLocalPathsOutputGroup;BuiltProjectOutputGroup</_TargetsForReferenceOutputs>
+        </PropertyGroup>
+        <!-- for each of our TFMs, we need to get a few kinds of outputs and put them into the package -->
+        <MSBuild Projects="$(MSBuildThisFileFullPath)" 
+            Targets="$(_TargetsForReferenceOutputs)">
+            <Output TaskParameter="TargetOutputs" ItemName="CurrentTFMOutputs" />
+        </MSBuild>
+        
         <ItemGroup>
-            <RequiredTaskFiles Include="..\CloudNimble.DotNetDocs.Sdk.Tasks\bin\$(Configuration)\**\*.dll" />
+            <CurrentTFMOutputs Update="@(CurrentTFMOutputs)" PackagePath="tasks\$(TargetFramework)\$([MSBuild]::ValueOrDefault('%(CurrentTFMOutputs.DestinationSubPath)', '%(CurrentTFMOutputs.TargetPath)'))" />
+            <TfmSpecificPackageFile Include="@(CurrentTFMOutputs)" />
         </ItemGroup>
-
-        <Error Text="Task assemblies not found in bin folder. The Tasks project must be built before packing the SDK with --no-build."
-               Condition="!Exists('@(RequiredTaskFiles)')" />
-
-        <Message Text="Using pre-built task assemblies from bin folder (NoBuild=true)" Importance="high" />
     </Target>
 
     <!-- Automatically push SDK package to local feed after pack -->
@@ -102,19 +94,4 @@
         <Message Text="📦 Pushed $(PackageId).$(PackageVersion) to local feed at $(LocalFeedPath)" Importance="high" Condition="'$(ErrorCode)' == '0'" />
         <Message Text="⚠️ Package already exists in local feed or push failed (this is OK for local development)" Importance="normal" Condition="'$(ErrorCode)' != '0'" />
     </Target>
-
-    <!-- Include NoTargets SDK files directly from package in NuGet -->
-    <Target Name="IncludeNoTargetsInPackage" BeforeTargets="GenerateNuspec">
-        <PropertyGroup>
-            <NoTargetsSourcePath>$(PkgMicrosoft_Build_NoTargets)\Sdk</NoTargetsSourcePath>
-        </PropertyGroup>
-        
-        <ItemGroup>
-            <NoTargetsFiles Include="$(NoTargetsSourcePath)\**\*" />
-            <None Include="@(NoTargetsFiles)" Pack="true" PackagePath="Sdk\NoTargets\%(RecursiveDir)%(Filename)%(Extension)" />
-        </ItemGroup>
-        
-        <Message Text="Including NoTargets SDK files in package from $(NoTargetsSourcePath)" Importance="normal" />
-    </Target>
-
 </Project>
\ No newline at end of file
diff --git a/src/CloudNimble.DotNetDocs.Sdk.Tasks/GenerateDocumentationTask.cs b/src/CloudNimble.DotNetDocs.Sdk/GenerateDocumentationTask.cs
similarity index 97%
rename from src/CloudNimble.DotNetDocs.Sdk.Tasks/GenerateDocumentationTask.cs
rename to src/CloudNimble.DotNetDocs.Sdk/GenerateDocumentationTask.cs
index df40733..2e89ab5 100644
--- a/src/CloudNimble.DotNetDocs.Sdk.Tasks/GenerateDocumentationTask.cs
+++ b/src/CloudNimble.DotNetDocs.Sdk/GenerateDocumentationTask.cs
@@ -295,16 +295,6 @@ public override bool Execute()
                     generatedFiles.AddRange(yamlFiles);
                 }
 
-                // Log statistics
-                Log.LogMessage(MessageImportance.High, "📊 Documentation Statistics:");
-                Log.LogMessage(MessageImportance.High, $"   📄 Documentation type: {DocumentationType}");
-                Log.LogMessage(MessageImportance.High, $"   📦 Assemblies processed: {assemblyPairs.Count}");
-                
-                if (generatedFiles.Count > 0)
-                {
-                    Log.LogMessage(MessageImportance.High, $"   📝 Files generated: {generatedFiles.Distinct().Count()}");
-                }
-
                 // Return generated files as output
                 GeneratedFiles = [.. generatedFiles.Distinct().Select(f => new TaskItem(f))];
 
@@ -497,7 +487,7 @@ internal NavigationConfig ParseNavigationConfig(XElement navigationElement)
         /// </summary>
         /// <param name="groupElement">The group XML element.</param>
         /// <returns>A GroupConfig instance, or null if parsing fails.</returns>
-        internal GroupConfig? ParseGroupConfig(XElement groupElement)
+        public GroupConfig? ParseGroupConfig(XElement groupElement)
         {
             var groupName = groupElement.Attribute("Name")?.Value;
             if (string.IsNullOrWhiteSpace(groupName))
@@ -551,7 +541,7 @@ internal NavigationConfig ParseNavigationConfig(XElement navigationElement)
         /// </summary>
         /// <param name="integrationsElement">The integrations XML element.</param>
         /// <returns>An IntegrationsConfig instance.</returns>
-        internal IntegrationsConfig ParseIntegrationsConfig(XElement integrationsElement)
+        public IntegrationsConfig ParseIntegrationsConfig(XElement integrationsElement)
         {
             var config = new IntegrationsConfig();
 
@@ -706,7 +696,7 @@ internal IntegrationsConfig ParseIntegrationsConfig(XElement integrationsElement
         /// </summary>
         /// <param name="stylingElement">The styling XML element.</param>
         /// <returns>A StylingConfig instance.</returns>
-        internal StylingConfig ParseStylingConfig(XElement stylingElement)
+        public StylingConfig ParseStylingConfig(XElement stylingElement)
         {
             var config = new StylingConfig();
 
@@ -732,7 +722,7 @@ internal StylingConfig ParseStylingConfig(XElement stylingElement)
         /// </summary>
         /// <param name="appearanceElement">The appearance XML element.</param>
         /// <returns>An AppearanceConfig instance.</returns>
-        internal AppearanceConfig ParseAppearanceConfig(XElement appearanceElement)
+        public AppearanceConfig ParseAppearanceConfig(XElement appearanceElement)
         {
             var config = new AppearanceConfig();
 
diff --git a/src/CloudNimble.DotNetDocs.Sdk/Sdk/Sdk.props b/src/CloudNimble.DotNetDocs.Sdk/Sdk/Sdk.props
index eef732a..f5b0e49 100644
--- a/src/CloudNimble.DotNetDocs.Sdk/Sdk/Sdk.props
+++ b/src/CloudNimble.DotNetDocs.Sdk/Sdk/Sdk.props
@@ -6,7 +6,6 @@
        Enables documentation files to be included in Visual Studio solutions
        without compilation overhead or bin/obj folder creation.
        ============================================================================ -->
-
     <PropertyGroup>
         <!-- Documentation project marker -->
         <IsDocumentationProject>true</IsDocumentationProject>
@@ -16,9 +15,6 @@
         <!-- This allows dotnet sln add to correctly add .docsproj files to solutions -->
         <DefaultProjectTypeGuid>{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</DefaultProjectTypeGuid>
 
-        <!-- Inherit from NoTargets SDK for no-compile behavior -->
-        <UsingMicrosoftNoTargetsSdk>true</UsingMicrosoftNoTargetsSdk>
-
         <!-- Default target framework -->
         <TargetFramework Condition="'$(TargetFramework)' == ''">net8.0</TargetFramework>
         
@@ -73,23 +69,7 @@
         <MSBuildProjectExtensionsPath>$(BaseIntermediateOutputPath)</MSBuildProjectExtensionsPath>
     </PropertyGroup>
 
-    <!-- Import the NoTargets SDK props for no-compile behavior -->
-    <!-- NoTargets SDK files are bundled in the Sdk/NoTargets folder -->
-    <!-- First try the local NoTargets folder (for packaged SDK) -->
-    <Import Project="$(MSBuildThisFileDirectory)NoTargets\Sdk.props" 
-            Condition="Exists('$(MSBuildThisFileDirectory)NoTargets\Sdk.props')" />
-    
-    <!-- Fallback: Try common NuGet package locations if local doesn't exist -->
-    <PropertyGroup Condition="!Exists('$(MSBuildThisFileDirectory)NoTargets\Sdk.props')">
-        <!-- Try standard NuGet cache location -->
-        <_NoTargetsFallbackPath>$(UserProfile)\.nuget\packages\microsoft.build.notargets\3.7.0\Sdk\Sdk.props</_NoTargetsFallbackPath>
-        <!-- For CI environments that might use different cache -->
-        <_NoTargetsFallbackPath Condition="!Exists('$(_NoTargetsFallbackPath)')">$(NuGetPackageRoot)microsoft.build.notargets\3.7.0\Sdk\Sdk.props</_NoTargetsFallbackPath>
-    </PropertyGroup>
-    
-    <!-- Import from NuGet cache if found -->
-    <Import Project="$(_NoTargetsFallbackPath)" 
-            Condition="!Exists('$(MSBuildThisFileDirectory)NoTargets\Sdk.props') and Exists('$(_NoTargetsFallbackPath)')" />
+    <Import Sdk="Microsoft.NET.Sdk" Project="Sdk.props" />
     
     <!-- Advanced Feature 2: Auto-Include Patterns by Documentation Type -->
     <!-- Common files for all documentation types -->
diff --git a/src/CloudNimble.DotNetDocs.Sdk/Sdk/Sdk.targets b/src/CloudNimble.DotNetDocs.Sdk/Sdk/Sdk.targets
index f39be88..8b40b65 100644
--- a/src/CloudNimble.DotNetDocs.Sdk/Sdk/Sdk.targets
+++ b/src/CloudNimble.DotNetDocs.Sdk/Sdk/Sdk.targets
@@ -6,23 +6,7 @@
         Includes validation, generation, and integration targets.
         ============================================================================ -->
 
-    <!-- Import the NoTargets SDK targets for no-compile behavior -->
-    <!-- NoTargets SDK files are bundled in the Sdk/NoTargets folder -->
-    <!-- First try the local NoTargets folder (for packaged SDK) -->
-    <Import Project="$(MSBuildThisFileDirectory)NoTargets\Sdk.targets" 
-            Condition="Exists('$(MSBuildThisFileDirectory)NoTargets\Sdk.targets')" />
-    
-    <!-- Fallback: Try common NuGet package locations if local doesn't exist -->
-    <PropertyGroup Condition="!Exists('$(MSBuildThisFileDirectory)NoTargets\Sdk.targets')">
-        <!-- Try standard NuGet cache location -->
-        <_NoTargetsTargetsFallbackPath>$(UserProfile)\.nuget\packages\microsoft.build.notargets\3.7.0\Sdk\Sdk.targets</_NoTargetsTargetsFallbackPath>
-        <!-- For CI environments that might use different cache -->
-        <_NoTargetsTargetsFallbackPath Condition="!Exists('$(_NoTargetsTargetsFallbackPath)')">$(NuGetPackageRoot)microsoft.build.notargets\3.7.0\Sdk\Sdk.targets</_NoTargetsTargetsFallbackPath>
-    </PropertyGroup>
-    
-    <!-- Import from NuGet cache if found -->
-    <Import Project="$(_NoTargetsTargetsFallbackPath)" 
-            Condition="!Exists('$(MSBuildThisFileDirectory)NoTargets\Sdk.targets') and Exists('$(_NoTargetsTargetsFallbackPath)')" />
+    <Import Sdk="Microsoft.NET.SDK" Project="Sdk.targets" />
     
     <!-- Determine which task assembly to load based on MSBuild runtime -->
     <PropertyGroup>
@@ -31,88 +15,91 @@
         <_DotNetDocsTaskFramework Condition="'$(MSBuildRuntimeType)' == 'Full'">net472</_DotNetDocsTaskFramework>
         <_DotNetDocsTaskFramework Condition="'$(_DotNetDocsTaskFramework)' == ''">net8.0</_DotNetDocsTaskFramework>
         
-        <!-- Tasks are always loaded from the packaged location -->
-        <_DotNetDocsTasksFolder>$(MSBuildThisFileDirectory)..\tasks\$(_DotNetDocsTaskFramework)</_DotNetDocsTasksFolder>
-        <_DotNetDocsTasksAssembly>$(_DotNetDocsTasksFolder)\CloudNimble.DotNetDocs.Sdk.Tasks.dll</_DotNetDocsTasksAssembly>
+        <!-- Tasks are loaded from the packaged location by default, but for testing it helps to have a property override -->
+        <_DotNetDocsTasksFolder Condition="'$(_DotNetDocsTasksFolder)' == ''">$(MSBuildThisFileDirectory)..\tasks\</_DotNetDocsTasksFolder>
+        <_DotNetDocsTasksAssembly >$(_DotNetDocsTasksFolder)$(_DotNetDocsTaskFramework)\CloudNimble.DotNetDocs.Sdk.dll</_DotNetDocsTasksAssembly>
+
+        <PrepareProjectReferencesDependsOn>AssignDocumentationProjectReferences;$(PrepareProjectReferencesDependsOn)</PrepareProjectReferencesDependsOn>
     </PropertyGroup>
     
-    <!-- Load compiled MSBuild tasks when they exist -->
-    <UsingTask TaskName="CloudNimble.DotNetDocs.Sdk.Tasks.DiscoverDocumentedProjectsTask" 
-               AssemblyFile="$(_DotNetDocsTasksAssembly)"
-               Condition="Exists('$(_DotNetDocsTasksAssembly)') AND '$(GenerateDocumentation)' == 'true'" />
     <UsingTask TaskName="CloudNimble.DotNetDocs.Sdk.Tasks.GenerateDocumentationTask" 
-               AssemblyFile="$(_DotNetDocsTasksAssembly)"
-               Condition="Exists('$(_DotNetDocsTasksAssembly)') AND '$(GenerateDocumentation)' == 'true'" />
-    
-    <!-- Clean up any implicit package references that might cause warnings -->
-    <Target Name="RemoveImplicitPackageReferences" BeforeTargets="CollectPackageReferences">
+               AssemblyFile="$(_DotNetDocsTasksAssembly)"/>
+
+    <!-- Synthetically creates ProjectReferences from this project to a broad cone of other projects in the workspace so that MSBuild
+         Common Targets will handle discovering the proper TFMs/Configuration/Platform/etc based on the parameters
+         used when building _this_ project -->
+    <Target Name="AssignDocumentationProjectReferences">
         <ItemGroup>
-            <PackageReference Remove="NETStandard.Library" />
-            <PackageReference Remove="Microsoft.NETCore.App" />
+            <!-- 
+                Start with all projects, then use a series of MSBuild invocations to decide which ones to orchestrate.
+                In general, to generate docs we need the primary output path and xmldoc paths for referenceable assemblies.
+                In MSBuild parlance, this means that we need to OutputPath and DocumentationFile properties from each project.
+                We also need to ensure that such projects are actually _built_ so that their outputs are available.
+            -->
+            <_AllProjectsInRoot Include="$(IncludePatterns)" Exclude="@(ExcludePatterns)"/>
+            <ProjectReference Include="@(_AllProjectsInRoot)" ReferenceOutputAssembly="false" />
         </ItemGroup>
     </Target>
 
-    <!-- Documentation project validation and information -->
-    <Target Name="ValidateDocumentationProject" BeforeTargets="Build">
-        <Message Text="✅ Documentation project: $(MSBuildProjectName)" Importance="high" />
-        <Message Text="📄 Documentation type: $(DocumentationType)" Importance="high" />
-        <Message Text="📂 Documentation root: $(DocumentationRoot)" Importance="high" Condition="'$(DocumentationRoot)' != '$(MSBuildProjectDirectory)\'" />
-        <Message Text="🔧 Generate documentation: $(GenerateDocumentation)" Importance="normal" />
-    </Target>
-
     <!-- Discover documented projects in solution for documentation generation -->
-    <Target Name="DiscoverDocumentedProjects" Condition="'$(GenerateDocumentation)' == 'true'" AfterTargets="ValidateDocumentationProject">
-        <Message Text="🔍 Discovering documented projects in solution..." Importance="high" />
-
-        <!-- Use compiled task to discover projects -->
-        <CloudNimble.DotNetDocs.Sdk.Tasks.DiscoverDocumentedProjectsTask
-            SolutionDir="$(MSBuildProjectDirectory)\.."
-            ExcludePatterns="$(ExcludePatterns)">
-            <Output TaskParameter="DocumentedProjects" ItemName="DocumentedProjects" />
-        </CloudNimble.DotNetDocs.Sdk.Tasks.DiscoverDocumentedProjectsTask>
-
-        <Message Text="📚 Found @(DocumentedProjects->Count()) documented projects for documentation" Importance="high" />
+    <!-- _MSBuildProjectReferenceExistent Items now exist thanks to PrepareProjectReferences.
+         From this set, we can call a couple Targets to determine which of these should actually be used to generate documentation -->
+    <!-- We can get documentation files for projects from the DocumentationProjectOutputGroup Target, 
+        and dlls from the BuiltProjectOutputGroup Target. HOWEVER these only exist on single-TFM projects, so 
+        first we need to ensure that we have 'negotiated' the correct TFM (and other properties) for each project. 
+    -->
+    <Target Name="DiscoverDocumentedProjects" Condition="'$(GenerateDocumentation)' == 'true'" DependsOnTargets="PrepareProjectReferences">
+        <MSBuild Projects="@(_MSBuildProjectReferenceExistent)"
+                 Targets="DocumentationProjectOutputGroup"
+                 Properties="%(_MSBuildProjectReferenceExistent.SetConfiguration); %(_MSBuildProjectReferenceExistent.SetPlatform); %(_MSBuildProjectReferenceExistent.SetTargetFramework)"
+                 SkipNonexistentTargets="true"
+                 BuildInParallel="true">
+            <Output TaskParameter="TargetOutputs" ItemName="_ProjectsWithDocFiles" />
+        </MSBuild>
+
+        <!-- The _ProjectsWithDocFiles items will have MSBuildSourceProjectFile metadata noting the project they came from.
+             We will assume that any item in this list belongs to a project that will actually generate docs for us to work with.
+            We take those _MSBuildProjectReferenceExistent so that they continue to have all the relevant properties set for future use.  -->
+        <ItemGroup>
+            <DocumentedProjects Include="@(_ProjectsWithDocFiles->Metadata('MSBuildSourceProjectFile'))"
+                                DocFile="%(_ProjectsWithDocFiles.Identity)" />
+        </ItemGroup>
         
-        <!-- Show the list of projects that will be documented -->
+        <!-- We also need to compute the dll outputs for the documented projects so we can get the dlls. Both the dlls and the xml docs will be 
+             Inputs to doc generation to allow for incrementality. -->
+        <MSBuild Projects="@(DocumentedProjects)"
+                 Targets="BuiltProjectOutputGroup"
+                 Properties="%(DocumentedProjects._ProjectsWithDocFiles); %(DocumentedProjects.SetPlatform); %(DocumentedProjects.SetTargetFramework)"
+                 SkipNonexistentTargets="true"
+                 BuildInParallel="true">
+            <Output TaskParameter="TargetOutputs" ItemName="_ProjectWithBuildOutputs" />
+        </MSBuild>
         <ItemGroup>
-            <_ProjectNames Include="@(DocumentedProjects->'%(Filename)')" />
+            <DocumentedProjectsWithOutputs Include="@(_ProjectWithBuildOutputs->Metadata('MSBuildSourceProjectFile'))"
+                                           Condition="%(_ProjectWithBuildOutputs.Extension) == '.dll'"
+                                           AssemblyFile="%(_ProjectWithBuildOutputs.Identity)" />
         </ItemGroup>
-        <Message Text="   Projects: @(_ProjectNames, ', ')" Importance="normal" />
     </Target>
 
-    <!-- Generate documentation from existing assemblies -->
+    <!-- Generate documentation from existing assemblies. TODO: is it possible to compute the set of outputs that are expected? That would help incrementality a ton -->
     <Target Name="GenerateDocumentation"
             Condition="'$(GenerateDocumentation)' == 'true'"
-            DependsOnTargets="DiscoverDocumentedProjects">
+            DependsOnTargets="DiscoverDocumentedProjects;ResolveProjectReferences">
         <Message Text="🚀 Generating documentation from existing assemblies..." Importance="high" />
 
         <!-- Extract assembly paths from built projects (only main project assemblies) -->
         <ItemGroup>
             <!-- Get assembly paths using the actual target framework from each project -->
-            <AssemblyPaths Include="%(DocumentedProjects.RootDir)%(DocumentedProjects.Directory)bin\$(Configuration)\%(DocumentedProjects.TargetFramework)\%(DocumentedProjects.Filename).dll" />
-            <XmlDocPaths Include="%(DocumentedProjects.RootDir)%(DocumentedProjects.Directory)bin\$(Configuration)\%(DocumentedProjects.TargetFramework)\%(DocumentedProjects.Filename).xml" />
+            <AssemblyPaths Include="%(DocumentedProjectsWithOutputs.AssemblyFile)" />
+            <XmlDocPaths Include="%(DocumentedProjectsWithOutputs.DocFile)" />
         </ItemGroup>
 
-        <Message Text="📁 Found @(AssemblyPaths->Count()) assemblies for documentation generation" Importance="normal" />
-        
-        <!-- Debug: Show assembly paths -->
-        <Message Text="   Assembly: %(AssemblyPaths.Identity)" Importance="normal" />
-
         <!-- Call DocumentationManager to process assemblies -->
         <PropertyGroup>
             <DocumentationRootPath>$(MSBuildProjectDirectory)</DocumentationRootPath>
             <NamespaceModeProperty>$(NamespaceMode)</NamespaceModeProperty>
         </PropertyGroup>
 
-        <!-- Create assembly list file for DocumentationManager (for debugging) -->
-        <WriteLinesToFile File="$(MSBuildProjectDirectory)\assembly-list.txt"
-                         Lines="@(AssemblyPaths)"
-                         Overwrite="true"
-                         Condition="'$(Configuration)' == 'Debug'" />
-
-        <Message Text="📝 Created assembly list: $(MSBuildProjectDirectory)\assembly-list.txt" Importance="normal" Condition="'$(Configuration)' == 'Debug'" />
-        <Message Text="🔧 Calling GenerateDocumentationTask with @(AssemblyPaths->Count()) assemblies" Importance="high" />
-
         <!-- Use compiled task to generate documentation -->
         <CloudNimble.DotNetDocs.Sdk.Tasks.GenerateDocumentationTask
             Assemblies="@(AssemblyPaths)"
@@ -129,12 +116,13 @@
             ShowPlaceholders="$(ShowPlaceholders)">
             <Output TaskParameter="GeneratedFiles" ItemName="GeneratedDocumentationFiles" />
         </CloudNimble.DotNetDocs.Sdk.Tasks.GenerateDocumentationTask>
+        
+        <ItemGroup>
+            <FileWrites Include="@(GeneratedDocumentationFiles)" />
+        </ItemGroup>
 
         <!-- Check result -->
         <Message Text="✅ Documentation generation completed successfully" Importance="high" />
-        <Message Text="📄 Generated @(GeneratedDocumentationFiles->Count()) documentation files" Importance="normal" Condition="@(GeneratedDocumentationFiles->Count()) > 0" />
-
-        <!-- DocumentationManager integration complete - merged model processing enabled -->
     </Target>
 
     <!-- Documentation project statistics -->
@@ -189,12 +177,10 @@
 
     <!-- Define a Build target that runs documentation generation -->
     <!-- This allows 'dotnet build' and Visual Studio builds to work -->
-    <Target Name="Build" DependsOnTargets="ValidateDocumentationProject;GenerateDocumentation;DocumentationStats">
+    <Target Name="Build" DependsOnTargets="GenerateDocumentation">
         <Message Text="✅ Documentation build completed" Importance="high" />
     </Target>
 
-
-
     <!-- Help target to show available options -->
     <Target Name="DocumentationHelp">
         <Message Text="" Importance="high" />
@@ -205,10 +191,8 @@
         <Message Text="  GenerateDocumentation=true    - Generate docs from all packable projects in solution" Importance="high" />
         <Message Text="  GenerateMintlifyDocs=true     - Auto-generate Mintlify docs on build" Importance="high" />
         <Message Text="  LintMarkdown=true             - Lint markdown files on build" Importance="high" />
-        <Message Text="  ValidateLinks=true            - Validate links on build" Importance="high" />
         <Message Text="  PreviewDocumentation=true     - Start preview server on build" Importance="high" />
         <Message Text="  ShowDocumentationStats=true   - Show documentation statistics" Importance="high" />
-        <Message Text="  GeneratePdf=true              - Generate PDF output" Importance="high" />
         <Message Text="  DeployDocumentation=true      - Deploy documentation after build" Importance="high" />
         <Message Text="" Importance="high" />
         <Message Text="Available Targets:" Importance="high" />
diff --git a/src/CloudNimble.DotNetDocs.Sdk/readme.md b/src/CloudNimble.DotNetDocs.Sdk/readme.md
index 737ea74..15834fb 100644
--- a/src/CloudNimble.DotNetDocs.Sdk/readme.md
+++ b/src/CloudNimble.DotNetDocs.Sdk/readme.md
@@ -93,8 +93,6 @@ The SDK automatically detects your documentation type based on configuration fil
     <DeployDocumentation>true</DeployDocumentation>
     
     <!-- Quality assurance -->
-    <ValidateLinks>true</ValidateLinks>
-    <GeneratePdf>true</GeneratePdf>
   </PropertyGroup>
 </Project>
 ```
@@ -130,8 +128,6 @@ This is particularly useful when you want to:
 | `GenerateMintlifyDocs` | Generate Mintlify documentation (requires EasyAF.Tools) |
 | `LintMarkdown` | Lint markdown files for issues |
 | `PreviewDocumentation` | Start local preview server |
-| `ValidateLinks` | Check for broken links |
-| `GeneratePdf` | Generate PDF output |
 | `DeployDocumentation` | Deploy to hosting platform |
 
 ### DotNetDocs Integration
diff --git a/src/CloudNimble.DotNetDocs.Sdk/work-plan.md b/src/CloudNimble.DotNetDocs.Sdk/work-plan.md
new file mode 100644
index 0000000..4eacccb
--- /dev/null
+++ b/src/CloudNimble.DotNetDocs.Sdk/work-plan.md
@@ -0,0 +1,14 @@
+* Improve current SDK implementation
+  * improve discovery Task/logic
+    * don't do eval in DiscoverDocumentedProjectsTask x
+      * instead use Target calls x
+    * ensure that referenced projects are built before documentation generation x
+    * incrementality
+    * add a placeholder for multi-tfm handling 
+  * improve sdk packaging x
+    * use nuget's per-tfm capabilities to do the current Task packaging x
+    * remove need for separate project x
+    * ensure deps are bundled per-TFM as well for correct loading x
+    * remove use of pinned-per-tfm extensions deps - newer versions are back-compatible x
+  * improve local use of custom SDK
+    * add explicit Imports to local samples for Sdk.props and Sdk.targets to remove need to build entire package and manage nuget package versions
diff --git a/src/CloudNimble.DotNetDocs.Tests.Sdk.Tasks/CloudNimble.DotNetDocs.Tests.Sdk.Tasks.csproj b/src/CloudNimble.DotNetDocs.Tests.Sdk.Tasks/CloudNimble.DotNetDocs.Tests.Sdk.Tasks.csproj
index 3aef87b..0a68e46 100644
--- a/src/CloudNimble.DotNetDocs.Tests.Sdk.Tasks/CloudNimble.DotNetDocs.Tests.Sdk.Tasks.csproj
+++ b/src/CloudNimble.DotNetDocs.Tests.Sdk.Tasks/CloudNimble.DotNetDocs.Tests.Sdk.Tasks.csproj
@@ -14,8 +14,9 @@
     </ItemGroup>
 
     <ItemGroup>
-        <ProjectReference Include="..\CloudNimble.DotNetDocs.Sdk.Tasks\CloudNimble.DotNetDocs.Sdk.Tasks.csproj" />
+        <ProjectReference Include="..\CloudNimble.DotNetDocs.Sdk\CloudNimble.DotNetDocs.Sdk.csproj" />
         <ProjectReference Include="..\CloudNimble.DotNetDocs.Tests.Shared\CloudNimble.DotNetDocs.Tests.Shared.csproj" />
+        <ProjectReference Include="..\Mintlify.Core\Mintlify.Core.csproj" />
     </ItemGroup>
 
     <ItemGroup>
diff --git a/src/CloudNimble.DotNetDocs.Tests.Sdk.Tasks/DiscoverDocumentedProjectsTaskTests.cs b/src/CloudNimble.DotNetDocs.Tests.Sdk.Tasks/DiscoverDocumentedProjectsTaskTests.cs
deleted file mode 100644
index de8a1f5..0000000
--- a/src/CloudNimble.DotNetDocs.Tests.Sdk.Tasks/DiscoverDocumentedProjectsTaskTests.cs
+++ /dev/null
@@ -1,302 +0,0 @@
-using System;
-using System.IO;
-using CloudNimble.DotNetDocs.Sdk.Tasks;
-using CloudNimble.DotNetDocs.Tests.Shared;
-using FluentAssertions;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
-
-namespace CloudNimble.DotNetDocs.Tests.Sdk.Tasks
-{
-
-    /// <summary>
-    /// Tests for the DiscoverDocumentedProjectsTask class, focusing on project discovery and filtering logic.
-    /// </summary>
-    [TestClass]
-    public class DiscoverDocumentedProjectsTaskTests : DotNetDocsTestBase
-    {
-
-        #region Fields
-
-        private DiscoverDocumentedProjectsTask _task = null!;
-        private string _tempDirectory = null!;
-
-        #endregion
-
-        #region Test Lifecycle
-
-        [TestInitialize]
-        public void TestInitialize()
-        {
-            TestSetup();
-            _task = new DiscoverDocumentedProjectsTask();
-
-            // Set up a minimal build engine to avoid logging errors
-            var buildEngine = new TestBuildEngine();
-            _task.BuildEngine = buildEngine;
-
-            // Create a temporary directory for test files
-            _tempDirectory = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
-            Directory.CreateDirectory(_tempDirectory);
-        }
-
-        [TestCleanup]
-        public void TestCleanup()
-        {
-            // Clean up temporary files
-            if (Directory.Exists(_tempDirectory))
-            {
-                Directory.Delete(_tempDirectory, true);
-            }
-
-            TestTearDown();
-        }
-
-        #endregion
-
-        #region Project Discovery Tests
-
-        /// <summary>
-        /// Tests that DiscoverProjectFiles finds all project types.
-        /// </summary>
-        [TestMethod]
-        public void DiscoverProjectFiles_WithValidDirectory_FindsAllProjectTypes()
-        {
-            // Create test project files
-            File.WriteAllText(Path.Combine(_tempDirectory, "Test1.csproj"), "<Project />");
-            File.WriteAllText(Path.Combine(_tempDirectory, "Test2.vbproj"), "<Project />");
-            File.WriteAllText(Path.Combine(_tempDirectory, "Test3.fsproj"), "<Project />");
-            File.WriteAllText(Path.Combine(_tempDirectory, "NotProject.txt"), "text file");
-
-            var result = _task.DiscoverProjectFiles(_tempDirectory, null);
-
-            result.Should().HaveCount(3);
-            result.Should().Contain(p => p.EndsWith("Test1.csproj"));
-            result.Should().Contain(p => p.EndsWith("Test2.vbproj"));
-            result.Should().Contain(p => p.EndsWith("Test3.fsproj"));
-        }
-
-        /// <summary>
-        /// Tests that DiscoverProjectFiles excludes projects based on patterns.
-        /// </summary>
-        [TestMethod]
-        public void DiscoverProjectFiles_WithExcludePatterns_ExcludesMatchingProjects()
-        {
-            // Create test project files
-            File.WriteAllText(Path.Combine(_tempDirectory, "MyProject.csproj"), "<Project />");
-            File.WriteAllText(Path.Combine(_tempDirectory, "MyProject.Tests.csproj"), "<Project />");
-            File.WriteAllText(Path.Combine(_tempDirectory, "MyProject.IntegrationTests.csproj"), "<Project />");
-
-            var excludePatterns = new[] { "Tests", "IntegrationTests" };
-            var result = _task.DiscoverProjectFiles(_tempDirectory, excludePatterns);
-
-            result.Should().HaveCount(1);
-            result.Should().Contain(p => p.EndsWith("MyProject.csproj"));
-        }
-
-        /// <summary>
-        /// Tests that DiscoverProjectFiles finds projects in subdirectories.
-        /// </summary>
-        [TestMethod]
-        public void DiscoverProjectFiles_WithSubdirectories_FindsProjectsRecursively()
-        {
-            // Create subdirectory and project
-            var subDir = Path.Combine(_tempDirectory, "SubFolder");
-            Directory.CreateDirectory(subDir);
-            File.WriteAllText(Path.Combine(subDir, "SubProject.csproj"), "<Project />");
-            File.WriteAllText(Path.Combine(_tempDirectory, "RootProject.csproj"), "<Project />");
-
-            var result = _task.DiscoverProjectFiles(_tempDirectory, null);
-
-            result.Should().HaveCount(2);
-            result.Should().Contain(p => p.EndsWith("RootProject.csproj"));
-            result.Should().Contain(p => p.EndsWith("SubProject.csproj"));
-        }
-
-        #endregion
-
-        #region Project Filtering Tests
-
-        /// <summary>
-        /// Tests that ShouldIncludeProject returns true when no exclude patterns are provided.
-        /// </summary>
-        [TestMethod]
-        public void ShouldIncludeProject_WithNoExcludePatterns_ReturnsTrue()
-        {
-            var projectPath = Path.Combine(_tempDirectory, "TestProject.csproj");
-
-            var result = _task.ShouldIncludeProject(projectPath, null);
-
-            result.Should().BeTrue();
-        }
-
-        /// <summary>
-        /// Tests that ShouldIncludeProject returns true when project doesn't match exclude patterns.
-        /// </summary>
-        [TestMethod]
-        public void ShouldIncludeProject_WithNonMatchingPatterns_ReturnsTrue()
-        {
-            var projectPath = Path.Combine(_tempDirectory, "MyProject.csproj");
-            var excludePatterns = new[] { "Tests", "Samples" };
-
-            var result = _task.ShouldIncludeProject(projectPath, excludePatterns);
-
-            result.Should().BeTrue();
-        }
-
-        /// <summary>
-        /// Tests that ShouldIncludeProject returns false when project matches exclude patterns.
-        /// </summary>
-        [TestMethod]
-        public void ShouldIncludeProject_WithMatchingPattern_ReturnsFalse()
-        {
-            var projectPath = Path.Combine(_tempDirectory, "MyProject.Tests.csproj");
-            var excludePatterns = new[] { "Tests", "Samples" };
-
-            var result = _task.ShouldIncludeProject(projectPath, excludePatterns);
-
-            result.Should().BeFalse();
-        }
-
-        /// <summary>
-        /// Tests that ShouldIncludeProject matching is case insensitive.
-        /// </summary>
-        [TestMethod]
-        public void ShouldIncludeProject_WithCaseInsensitiveMatch_ReturnsFalse()
-        {
-            var projectPath = Path.Combine(_tempDirectory, "MyProject.TESTS.csproj");
-            var excludePatterns = new[] { "tests" };
-
-            var result = _task.ShouldIncludeProject(projectPath, excludePatterns);
-
-            result.Should().BeFalse();
-        }
-
-        /// <summary>
-        /// Tests that ShouldIncludeProject handles wildcard patterns correctly.
-        /// </summary>
-        [TestMethod]
-        public void ShouldIncludeProject_WithWildcardPattern_HandlesCorrectly()
-        {
-            var projectPath = Path.Combine(_tempDirectory, "MyProject.Tests.csproj");
-            var excludePatterns = new[] { "*Tests*" };
-
-            var result = _task.ShouldIncludeProject(projectPath, excludePatterns);
-
-            result.Should().BeFalse();
-        }
-
-        #endregion
-
-        #region Properties Tests
-
-        /// <summary>
-        /// Tests that _propertiesToEvaluate contains the expected properties and values.
-        /// </summary>
-        [TestMethod]
-        public void PropertiesToEvaluate_ContainsExpectedProperties()
-        {
-            _task._propertiesToEvaluate.Should().ContainKey("IsTestProject")
-                .WhoseValue.Should().BeFalse();
-            _task._propertiesToEvaluate.Should().ContainKey("IsPackable")
-                .WhoseValue.Should().BeTrue();
-            _task._propertiesToEvaluate.Should().ContainKey("ExcludeFromDocumentation")
-                .WhoseValue.Should().BeFalse();
-        }
-
-        /// <summary>
-        /// Tests that properties can be modified for testing scenarios.
-        /// </summary>
-        [TestMethod]
-        public void PropertiesToEvaluate_CanBeModified()
-        {
-            _task._propertiesToEvaluate["IsTestProject"] = true;
-            _task._propertiesToEvaluate.Should().ContainKey("IsTestProject")
-                .WhoseValue.Should().BeTrue();
-        }
-
-        #endregion
-
-        #region Task Property Tests
-
-        /// <summary>
-        /// Tests that task properties have correct default values.
-        /// </summary>
-        [TestMethod]
-        public void TaskProperties_HaveCorrectDefaults()
-        {
-            _task.Configuration.Should().Be("Release");
-            _task.TargetFramework.Should().Be("net8.0");
-            _task.DocumentedProjects.Should().BeEmpty();
-        }
-
-        /// <summary>
-        /// Tests that task properties can be set.
-        /// </summary>
-        [TestMethod]
-        public void TaskProperties_CanBeSet()
-        {
-            _task.SolutionDir = "C:\\TestSolution";
-            _task.Configuration = "Debug";
-            _task.TargetFramework = "net9.0";
-            _task.ExcludePatterns = new[] { "Tests" };
-
-            _task.SolutionDir.Should().Be("C:\\TestSolution");
-            _task.Configuration.Should().Be("Debug");
-            _task.TargetFramework.Should().Be("net9.0");
-            _task.ExcludePatterns.Should().ContainSingle("Tests");
-        }
-
-        #endregion
-
-        #region Argument Validation Tests
-
-        /// <summary>
-        /// Tests that DiscoverProjectFiles throws ArgumentException for null or whitespace solution directory.
-        /// </summary>
-        [TestMethod]
-        public void DiscoverProjectFiles_WithNullSolutionDir_ThrowsArgumentException()
-        {
-            var action = () => _task.DiscoverProjectFiles(null!, null);
-
-            action.Should().Throw<ArgumentException>();
-        }
-
-        /// <summary>
-        /// Tests that DiscoverProjectFiles throws ArgumentException for whitespace solution directory.
-        /// </summary>
-        [TestMethod]
-        public void DiscoverProjectFiles_WithWhitespaceSolutionDir_ThrowsArgumentException()
-        {
-            var action = () => _task.DiscoverProjectFiles("   ", null);
-
-            action.Should().Throw<ArgumentException>();
-        }
-
-        /// <summary>
-        /// Tests that ShouldIncludeProject throws ArgumentException for null or whitespace project file path.
-        /// </summary>
-        [TestMethod]
-        public void ShouldIncludeProject_WithNullProjectPath_ThrowsArgumentException()
-        {
-            var action = () => _task.ShouldIncludeProject(null!, null);
-
-            action.Should().Throw<ArgumentException>();
-        }
-
-        /// <summary>
-        /// Tests that ShouldIncludeProject throws ArgumentException for whitespace project file path.
-        /// </summary>
-        [TestMethod]
-        public void ShouldIncludeProject_WithWhitespaceProjectPath_ThrowsArgumentException()
-        {
-            var action = () => _task.ShouldIncludeProject("   ", null);
-
-            action.Should().Throw<ArgumentException>();
-        }
-
-        #endregion
-
-
-    }
-
-}
\ No newline at end of file
diff --git a/test/MultiAssembly.ByAssembly.docsproj b/test/MultiAssembly.ByAssembly.docsproj
index 260f745..ecb48f6 100644
--- a/test/MultiAssembly.ByAssembly.docsproj
+++ b/test/MultiAssembly.ByAssembly.docsproj
@@ -1,11 +1,15 @@
-<Project Sdk="CloudNimble.DotNetDocs.Sdk/1.0.0">
+<Project>
 
+  <Import Project="..\src\CloudNimble.DotNetDocs.Sdk\Sdk\Sdk.props" />
   <PropertyGroup>
     <!-- ByAssembly navigation mode - separate groups per assembly -->
     <DocumentationRoot>$(MSBuildProjectDirectory)\byassembly-docs\</DocumentationRoot>
+    <GenerateDocumentation>true</GenerateDocumentation>
     <DocumentationType>Mintlify</DocumentationType>
     <NamespaceMode>Folder</NamespaceMode>
     <MintlifyNavigationMode>ByAssembly</MintlifyNavigationMode>
+    <ExcludePatterns>*.docsproj;**.docsproj</ExcludePatterns>
+    <IncludePatterns>../src/**/*.csproj</IncludePatterns>
     
     <!-- Inline Mintlify template configuration -->
     <MintlifyTemplate>
@@ -34,4 +38,10 @@
     <Assembly Include="..\src\Mintlify.Core\bin\$(Configuration)\net8.0\Mintlify.Core.dll" />
   </ItemGroup>
 
+  <PropertyGroup>
+    <_DotNetDocsTasksFolder>$(MSBuildThisFileDirectory)..\src\CloudNimble.DotNetDocs.Sdk\bin\Debug\</_DotNetDocsTasksFolder>
+  </PropertyGroup>
+
+  <Import Project="..\src\CloudNimble.DotNetDocs.Sdk\Sdk\Sdk.targets" />
+
 </Project>
\ No newline at end of file