Dependencies: propagate LastSuccessful through transitive deps

When a parametrized dep is LastSuccessful, the consumer doesn't trigger
that dep's build — so chaining the build of its transitive deps is
pointless and ends up generating snapshot dependencies that needlessly
hold back the consumer's build/deploy.

Example seen on MetalamaVsx 2026.1: both Metalama 2026.1 and Metalama
2026.0 are LastSuccessful, but their transitive Metalama.Compiler ref
(its own ArtifactPickup defaults to Snapshot) caused a snapshot dep on
Metalama.Compiler in the deploy config.

Fix: GetAllDependencies now threads an `ancestorIsLastSuccessful` flag
through the recursion. Any dep reached via a LastSuccessful ancestor
gets EffectiveArtifactPickup = LastSuccessful in the returned
DependencyConfiguration. ArtifactPickup consults the effective value
first, so existing call sites (ConfigurationProperties snapshot dep
generation, deploy-config filtering) automatically pick up the
propagation without changes. EffectiveArtifactPickup is internal — it's
an implementation detail set by GetAllDependencies, not a consumer-side
override.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

Author: PostSharpAgent

src/PostSharp.Engineering.BuildTools/Dependencies/Model/DependencyConfiguration.cs

@@ -29,10 +29,21 @@ public record DependencyConfiguration( DependencyDefinition Definition, BuildCon
     /// </summary>
     public string KeyWithoutDot => this.Parametrized?.KeyWithoutDot ?? this.Definition.NameWithoutDot;
 
+    /// <summary>
+    /// Gets the effective artifact pickup mode after propagation through the dep graph (set by
+    /// <see cref="DependencyDefinition.GetAllDependencies"/>). When a transitive dep is reached only via a
+    /// <see cref="DependencyArtifactPickup.LastSuccessful"/> ancestor, this is forced to <see cref="DependencyArtifactPickup.LastSuccessful"/>
+    /// so the consumer doesn't generate snapshot dependencies on a subtree whose root build it doesn't trigger.
+    /// </summary>
+    internal DependencyArtifactPickup? EffectiveArtifactPickup { get; init; }
+
     /// <summary>
     /// Gets the artifact pickup mode at the consumer's use site, defaulting to <see cref="DependencyArtifactPickup.Snapshot"/>.
+    /// Returns <see cref="EffectiveArtifactPickup"/> when set (via <see cref="DependencyDefinition.GetAllDependencies"/>),
+    /// otherwise falls back to the parametrized dep's own setting.
     /// </summary>
-    public DependencyArtifactPickup ArtifactPickup => this.Parametrized?.ArtifactPickup ?? DependencyArtifactPickup.Snapshot;
+    public DependencyArtifactPickup ArtifactPickup
+        => this.EffectiveArtifactPickup ?? this.Parametrized?.ArtifactPickup ?? DependencyArtifactPickup.Snapshot;
 
     public virtual bool Equals( DependencyConfiguration? other )
         => other is not null

src/PostSharp.Engineering.BuildTools/Dependencies/Model/DependencyDefinition.cs

@@ -76,24 +76,36 @@ public class DependencyDefinition
         public IReadOnlySet<DependencyConfiguration> GetAllDependencies( BuildConfiguration buildConfiguration )
         {
             HashSet<DependencyConfiguration> dependencies = new();
-            PopulateRecursive( this, buildConfiguration );
+            PopulateRecursive( this, buildConfiguration, ancestorIsLastSuccessful: false );
 
             return dependencies;
 
-            void PopulateRecursive( DependencyDefinition dependency, BuildConfiguration configuration )
+            void PopulateRecursive( DependencyDefinition dependency, BuildConfiguration configuration, bool ancestorIsLastSuccessful )
             {
                 foreach ( var child in dependency.Dependencies )
                 {
                     var childConfiguration = child.ConfigurationMapping[configuration];
 
-                    var dependencyConfiguration = new DependencyConfiguration( child, childConfiguration ) { Parametrized = child };
+                    // Propagate LastSuccessful through transitive deps: if any ancestor on the path from the consumer to
+                    // this child is LastSuccessful, we don't trigger that ancestor's build, so chaining the build of its
+                    // transitive deps is pointless. Treat the whole subtree under a LastSuccessful node as LastSuccessful.
+                    var childIsLastSuccessful = ancestorIsLastSuccessful || child.ArtifactPickup == DependencyArtifactPickup.LastSuccessful;
+
+                    var effectivePickup = childIsLastSuccessful
+                        ? DependencyArtifactPickup.LastSuccessful
+                        : child.ArtifactPickup;
+
+                    var dependencyConfiguration = new DependencyConfiguration( child, childConfiguration )
+                    {
+                        Parametrized = child, EffectiveArtifactPickup = effectivePickup
+                    };
 
                     if ( !dependencies.Add( dependencyConfiguration ) )
                     {
                         continue;
                     }
 
-                    PopulateRecursive( child, childConfiguration );
+                    PopulateRecursive( child, childConfiguration, childIsLastSuccessful );
                 }
             }
         }