@phuc1403/musketeer 0.10.0 → 0.11.0

package/template/.claude/skills/logical-components/scripts/LogicalComponents/MemberUseResolution.cs

@@ -0,0 +1,203 @@
+using System.Collections.Immutable;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+
+namespace LogicalComponents;
+
+/// <summary>
+/// Follows what a component's code uses until it lands on another component. A use of a member of:
+/// <list type="bullet">
+/// <item>a component is an edge to it;</item>
+/// <item>an interface or abstract class (a seam) goes on to the member that runs in each implementation of the
+/// construction used (see <see cref="SeamDispatch"/>);</item>
+/// <item>any other type of the repo (a helper, a record, a non-candidate) is seen through: the code that runs for that
+/// use is walked the same way, with the helper's type parameters bound to the use's type arguments (see
+/// <see cref="TypeMap"/>). It is walked per member and per accessor, so reading one property never couples to what
+/// another member or the setter calls, and compiler-written record members run nothing.</item>
+/// </list>
+/// Framework and library members end the walk. The kind of an edge is the kind of the last use; its citation is the
+/// line in the component where the chain starts; <c>via</c> names the seams and seen-through types on the first path
+/// found (members already walked for a component are not walked again). The helper code walked is the component's
+/// <c>reaches</c>.
+/// </summary>
+public sealed class MemberUseResolution(LoadedWorkspace loaded, IReadOnlySet<string> components, PortResolution ports)
+{
+    public sealed record RawEdge(string From, string To, string Kind, IReadOnlyList<string> Via, string File, int Line);
+
+    /// <summary>The edges a component's code leads to, and the helper code it runs on the way (sorted, distinct).</summary>
+    public sealed record Resolution(List<RawEdge> Edges, List<SourceSpan> Reaches);
+
+    // Shared by every component's walk: what a piece of syntax uses never changes within one loaded solution.
+    private readonly Dictionary<SyntaxNode, List<MemberUses.MemberUse>> _uses = [];
+    private readonly Dictionary<INamedTypeSymbol, bool> _repoSource = new(SymbolEqualityComparer.Default);
+
+    /// <summary>
+    /// The edges from <paramref name="from"/> reached by <paramref name="uses"/>. <paramref name="self"/> holds the
+    /// component and the base classes whose code counts as its own: uses of those are not coupling.
+    /// </summary>
+    public async Task<Resolution> ResolveAsync(
+        string from, IReadOnlySet<string> self, IEnumerable<MemberUses.MemberUse> uses, CancellationToken cancellationToken)
+    {
+        var walk = new Walk(from, self);
+        foreach (var use in uses)
+        {
+            await ResolveUseAsync(use.Member, use.Kind, [], use.File, use.Line, TypeMap.Empty, walk, cancellationToken);
+        }
+
+        return new Resolution(
+            walk.Edges,
+            walk.Reaches.OrderBy(s => s.File, StringComparer.Ordinal).ThenBy(s => s.Start).ThenBy(s => s.End).ToList());
+    }
+
+    // One component's walk: members already seen through (for the same type bindings) are not walked again, which also
+    // ends cycles.
+    private sealed class Walk(string from, IReadOnlySet<string> self)
+    {
+        public string From { get; } = from;
+        public IReadOnlySet<string> Self { get; } = self;
+        public HashSet<string> Visited { get; } = new(StringComparer.Ordinal);
+        public List<RawEdge> Edges { get; } = [];
+        public HashSet<SourceSpan> Reaches { get; } = [];
+    }
+
+    private async Task ResolveUseAsync(
+        ISymbol member,
+        string kind,
+        ImmutableList<string> via,
+        string file,
+        int line,
+        TypeMap map,
+        Walk walk,
+        CancellationToken cancellationToken)
+    {
+        // A C# 14 extension member belongs to the static class around its extension block.
+        var declaring = member.ContainingType is { IsExtension: true } block ? block.ContainingType : member.ContainingType;
+        if (declaring is null)
+        {
+            return;
+        }
+
+        if (map.Substitute(declaring) is INamedTypeSymbol bound)
+        {
+            declaring = bound;
+        }
+
+        var owner = EdgeExtraction.Normalize(declaring.OriginalDefinition);
+        if (!IsRepo(owner) || walk.Self.Contains(SymbolNames.FullName(owner)))
+        {
+            return;
+        }
+
+        if (components.Contains(SymbolNames.FullName(owner)))
+        {
+            walk.Edges.Add(new RawEdge(walk.From, SymbolNames.FullName(owner), kind, via, file, line));
+            return;
+        }
+
+        if (EdgeExtraction.IsSeam(declaring) && !member.IsStatic && kind != EdgeExtraction.New)
+        {
+            foreach (var implementation in await ports.ImplementationsAsync(declaring, cancellationToken))
+            {
+                if (SeamDispatch.ImplementationOf(implementation, declaring, member) is not { } runs)
+                {
+                    continue;
+                }
+
+                // An inherited default body lives on the seam itself: walk it rather than resolve the seam again.
+                if (runs.ContainingType is { } runsIn && EdgeExtraction.IsSeam(runsIn))
+                {
+                    await SeeThroughAsync(runs, kind, via.Add(declaring.Name), file, line, map, walk, cancellationToken);
+                }
+                else
+                {
+                    await ResolveUseAsync(runs, kind, via.Add(declaring.Name), file, line, TypeMap.Empty, walk, cancellationToken);
+                }
+            }
+
+            return;
+        }
+
+        await SeeThroughAsync(member, kind, via.Add(owner.Name), file, line, map, walk, cancellationToken);
+    }
+
+    private async Task SeeThroughAsync(
+        ISymbol member,
+        string kind,
+        ImmutableList<string> via,
+        string file,
+        int line,
+        TypeMap map,
+        Walk walk,
+        CancellationToken cancellationToken)
+    {
+        // Compiler-written members (a record's ToString/Equals/Deconstruct, an auto-property accessor) run nothing of the
+        // type's own code; their declaring syntax is the whole type, which must not be walked. Constructors still run
+        // initializers. Using an instance field runs no code: its initializer ran when the object was constructed.
+        if ((member.IsImplicitlyDeclared && kind != EdgeExtraction.New) || member is IFieldSymbol { IsStatic: false })
+        {
+            return;
+        }
+
+        var inner = map.For(member);
+        var key = (kind == EdgeExtraction.New ? "new " : "") + SymbolNames.MemberId(member) + "|" + inner.Key;
+        if (!walk.Visited.Add(key))
+        {
+            return;
+        }
+
+        var (roots, runsImplicitBase) = kind == EdgeExtraction.New && member is IMethodSymbol constructor
+            ? WalkRoots.Construction(constructor)
+            : (WalkRoots.Body(member), false);
+        Record(roots, walk);
+
+        foreach (var root in roots)
+        {
+            foreach (var use in await UsesAsync(root, cancellationToken))
+            {
+                await ResolveUseAsync(use.Member, use.Kind, via, file, line, inner, walk, cancellationToken);
+            }
+        }
+
+        if (runsImplicitBase
+            && member.ContainingType.BaseType?.InstanceConstructors.FirstOrDefault(c => c.Parameters.Length == 0) is { } baseConstructor)
+        {
+            await ResolveUseAsync(baseConstructor, EdgeExtraction.New, via, file, line, inner, walk, cancellationToken);
+        }
+    }
+
+    // The walked helper code becomes citable for the component; a parameter declares a value and runs nothing.
+    private void Record(IEnumerable<SyntaxNode> roots, Walk walk)
+    {
+        foreach (var root in roots.Where(r => r is not (ParameterSyntax or ParameterListSyntax)))
+        {
+            var (sourceKind, relative) = CitableSource.Classify(loaded, root.SyntaxTree);
+            if (sourceKind == CitableSource.Kind.InRepo)
+            {
+                var lines = root.GetLocation().GetLineSpan();
+                walk.Reaches.Add(new SourceSpan(relative, lines.StartLinePosition.Line + 1, lines.EndLinePosition.Line + 1));
+            }
+        }
+    }
+
+    private async Task<List<MemberUses.MemberUse>> UsesAsync(SyntaxNode root, CancellationToken cancellationToken)
+    {
+        if (!_uses.TryGetValue(root, out var uses))
+        {
+            uses = await MemberUses.ReadAsync([root], loaded, cancellationToken);
+            _uses[root] = uses;
+        }
+
+        return uses;
+    }
+
+    private bool IsRepo(INamedTypeSymbol type)
+    {
+        if (!_repoSource.TryGetValue(type, out var isRepo))
+        {
+            isRepo = CitableSource.IsRepoSource(type, loaded);
+            _repoSource[type] = isRepo;
+        }
+
+        return isRepo;
+    }
+}

package/template/.claude/skills/logical-components/scripts/LogicalComponents/MemberUses.cs

@@ -0,0 +1,155 @@
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+
+namespace LogicalComponents;
+
+/// <summary>
+/// Reads what a piece of code uses, as members: <c>new</c> (the constructor an object creation, a <c>: this(...)</c> /
+/// <c>: base(...)</c> initializer or a primary-constructor base call runs), <c>static</c> (a static member, an extension
+/// method or C# 14 extension member, a user-defined operator or conversion) and <c>call</c> (an instance member used on
+/// any receiver, an indexer, the enumerator a <c>foreach</c> runs). A property or indexer use is the accessor that
+/// actually runs: a read is the getter, an assignment the setter, a compound assignment or increment both. Only
+/// citable source is read, so generator output never contributes. What a use couples to is decided by
+/// <see cref="MemberUseResolution"/>.
+/// </summary>
+public static class MemberUses
+{
+    /// <summary>One use of <see cref="Member"/>, at a repo-relative file and 1-based line.</summary>
+    public sealed record MemberUse(ISymbol Member, string Kind, string File, int Line);
+
+    /// <summary>Every member use inside the given syntax nodes, in source order. Nodes outside the repo are skipped.</summary>
+    public static async Task<List<MemberUse>> ReadAsync(
+        IEnumerable<SyntaxNode> roots, LoadedWorkspace loaded, CancellationToken cancellationToken)
+    {
+        var uses = new List<MemberUse>();
+        foreach (var root in roots)
+        {
+            var (kind, file) = CitableSource.Classify(loaded, root.SyntaxTree);
+            if (kind != CitableSource.Kind.InRepo || loaded.Solution.GetDocument(root.SyntaxTree) is not { } document)
+            {
+                continue;
+            }
+
+            var model = await document.GetSemanticModelAsync(cancellationToken)
+                ?? throw new InvalidOperationException($"No semantic model for {file}");
+            foreach (var node in root.DescendantNodesAndSelf())
+            {
+                var line = node.GetLocation().GetLineSpan().StartLinePosition.Line + 1;
+                uses.AddRange(Uses(node, model, cancellationToken).Select(u => new MemberUse(u.Member, u.Kind, file, line)));
+            }
+        }
+
+        return uses;
+    }
+
+    private static IEnumerable<(ISymbol Member, string Kind)> Uses(SyntaxNode node, SemanticModel model, CancellationToken token)
+    {
+        ISymbol? Symbol() => model.GetSymbolInfo(node, token).Symbol;
+
+        switch (node)
+        {
+            case BaseObjectCreationExpressionSyntax or ConstructorInitializerSyntax or PrimaryConstructorBaseTypeSyntax:
+                if (Symbol() is IMethodSymbol constructor)
+                {
+                    yield return (constructor, EdgeExtraction.New);
+                }
+
+                break;
+            case SimpleNameSyntax name when !IsInsideNameOf(name, model):
+                foreach (var use in Classify(Symbol(), name))
+                {
+                    yield return use;
+                }
+
+                break;
+            case ElementAccessExpressionSyntax when Symbol() is IPropertySymbol indexer:
+                foreach (var accessor in AccessorsThatRun(indexer, node))
+                {
+                    yield return (accessor, EdgeExtraction.Call);
+                }
+
+                break;
+            case BinaryExpressionSyntax or PrefixUnaryExpressionSyntax or PostfixUnaryExpressionSyntax
+                or CastExpressionSyntax or AssignmentExpressionSyntax
+                when Symbol() is IMethodSymbol { MethodKind: MethodKind.UserDefinedOperator or MethodKind.Conversion } op:
+                yield return (op, EdgeExtraction.Static);
+                break;
+            case CommonForEachStatementSyntax loop when model.GetForEachStatementInfo(loop).GetEnumeratorMethod is { } enumerator:
+                yield return (enumerator, enumerator.IsStatic ? EdgeExtraction.Static : EdgeExtraction.Call);
+                break;
+        }
+    }
+
+    /// <summary>
+    /// A symbol a name refers to, as uses: static or extension members are <c>static</c> (a classic extension method is
+    /// seen as its unreduced static form), other members are <c>call</c>, a property is the accessors that run. Locals,
+    /// parameters, types, namespaces and consts (copied into the caller at compile time) are not uses.
+    /// </summary>
+    private static IEnumerable<(ISymbol, string)> Classify(ISymbol? symbol, SyntaxNode usage)
+    {
+        var kind = symbol is not null && (symbol.IsStatic || symbol.ContainingType is { IsExtension: true })
+            ? EdgeExtraction.Static
+            : EdgeExtraction.Call;
+        switch (symbol)
+        {
+            case IFieldSymbol { IsConst: true }:
+            case IMethodSymbol { MethodKind: MethodKind.LocalFunction or MethodKind.AnonymousFunction }:
+                break;
+            case IMethodSymbol { ReducedFrom: { } extension }:
+                yield return (extension, EdgeExtraction.Static);
+                break;
+            case IPropertySymbol property:
+                foreach (var accessor in AccessorsThatRun(property, usage))
+                {
+                    yield return (accessor, kind);
+                }
+
+                break;
+            case IMethodSymbol or IFieldSymbol or IEventSymbol:
+                yield return (symbol, kind);
+                break;
+        }
+    }
+
+    /// <summary>
+    /// The accessors a property or indexer use runs, from where it stands: the target of <c>=</c> (including an object
+    /// initializer) runs the setter; a compound assignment, <c>++</c>/<c>--</c>, or a <c>ref</c>/<c>out</c> argument runs
+    /// both; anything else is a read and runs the getter. An accessor the property does not have runs nothing.
+    /// </summary>
+    private static IEnumerable<IMethodSymbol> AccessorsThatRun(IPropertySymbol property, SyntaxNode usage)
+    {
+        // The whole access expression: `a.B` for the name B, `a?.B` for a conditional access, the name itself otherwise.
+        var access = usage.Parent switch
+        {
+            MemberAccessExpressionSyntax member when member.Name == usage => member,
+            MemberBindingExpressionSyntax binding => (SyntaxNode)binding,
+            _ => usage,
+        };
+
+        var (reads, writes) = access.Parent switch
+        {
+            AssignmentExpressionSyntax assignment when assignment.Left == access =>
+                (!assignment.IsKind(SyntaxKind.SimpleAssignmentExpression), true),
+            PrefixUnaryExpressionSyntax or PostfixUnaryExpressionSyntax => (true, true),
+            ArgumentSyntax { RefKindKeyword.RawKind: not 0 } => (true, true),
+            _ => (true, false),
+        };
+
+        if (reads && property.GetMethod is { } getter)
+        {
+            yield return getter;
+        }
+
+        if (writes && property.SetMethod is { } setter)
+        {
+            yield return setter;
+        }
+    }
+
+    // nameof(Foo.Bar) mentions a member without using it.
+    private static bool IsInsideNameOf(SyntaxNode node, SemanticModel model) =>
+        node.Ancestors().OfType<InvocationExpressionSyntax>().Any(invocation =>
+            invocation.Expression is IdentifierNameSyntax { Identifier.Text: "nameof" }
+            && model.GetSymbolInfo(invocation).Symbol is null);
+}

package/template/.claude/skills/logical-components/scripts/LogicalComponents/PortResolution.cs

@@ -0,0 +1,75 @@
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.FindSymbols;
+
+namespace LogicalComponents;
+
+/// <summary>
+/// Maps a seam (an interface or abstract class) to the concrete classes behind it in the loaded solution. Test
+/// projects were removed at load time, so test doubles never appear. Asking the type system rather than parsing DI
+/// registrations covers every registration style (instance, factory, forwarding) at once.
+/// A constructed generic seam (<c>IHandler&lt;Order&gt;</c>) resolves only to classes implementing exactly that construction,
+/// or an open generic one (<c>LoggingHandler&lt;T&gt; : IHandler&lt;T&gt;</c>). Results are cached per construction and sorted.
+/// </summary>
+public sealed class PortResolution(Solution solution)
+{
+    private readonly Dictionary<string, IReadOnlyList<INamedTypeSymbol>> _cache = new(StringComparer.Ordinal);
+
+    public async Task<IReadOnlyList<INamedTypeSymbol>> ImplementationsAsync(
+        INamedTypeSymbol seam, CancellationToken cancellationToken)
+    {
+        var key = Display(seam);
+        if (_cache.TryGetValue(key, out var cached))
+        {
+            return cached;
+        }
+
+        var definition = seam.OriginalDefinition;
+        IEnumerable<INamedTypeSymbol> found = definition.TypeKind == TypeKind.Interface
+            ? (await SymbolFinder.FindImplementationsAsync(definition, solution, cancellationToken: cancellationToken))
+                .OfType<INamedTypeSymbol>()
+            : await SymbolFinder.FindDerivedClassesAsync(definition, solution, transitive: true, cancellationToken: cancellationToken);
+
+        var implementations = found
+            .Where(t => t.TypeKind == TypeKind.Class && !t.IsAbstract)
+            .Select(t => t.OriginalDefinition)
+            .Where(t => ImplementsConstruction(t, seam))
+            .DistinctBy(SymbolNames.FullName)
+            .OrderBy(SymbolNames.FullName, StringComparer.Ordinal)
+            .ToList();
+        _cache[key] = implementations;
+        return implementations;
+    }
+
+    private static bool ImplementsConstruction(INamedTypeSymbol implementation, INamedTypeSymbol seam)
+    {
+        if (!seam.IsGenericType || seam.TypeArguments.All(a => a is ITypeParameterSymbol))
+        {
+            return true;
+        }
+
+        var definition = SymbolNames.FullName(seam.OriginalDefinition);
+        var wanted = Display(seam);
+        return Supertypes(implementation, seam.TypeKind).Any(s =>
+            SymbolNames.FullName(s.OriginalDefinition) == definition
+            && (Display(s) == wanted || s.TypeArguments.Any(a => a is ITypeParameterSymbol)));
+    }
+
+    private static IEnumerable<INamedTypeSymbol> Supertypes(INamedTypeSymbol type, TypeKind seamKind)
+    {
+        if (seamKind == TypeKind.Interface)
+        {
+            return type.AllInterfaces;
+        }
+
+        var bases = new List<INamedTypeSymbol>();
+        for (var current = type.BaseType; current is not null; current = current.BaseType)
+        {
+            bases.Add(current);
+        }
+
+        return bases;
+    }
+
+    // Compared as text: symbols of the same type seen from two projects' compilations are not always the same instance.
+    private static string Display(ITypeSymbol type) => type.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat);
+}

package/template/.claude/skills/logical-components/scripts/LogicalComponents/Program.cs

@@ -0,0 +1,27 @@
+using LogicalComponents;
+
+// Entry point: dispatches to one command per pipeline step. Anything unknown prints usage and exits 1.
+// candidates, extract and render report on stderr (their artifact is a file); the others report on stdout.
+return args switch
+{
+    ["candidates", .. var rest] => await CandidatesCommand.RunAsync(rest, Console.Error),
+    ["classify-batches", .. var rest] => await ClassifyBatchesCommand.RunAsync(rest, Console.Out),
+    ["classify-merge", .. var rest] => await ClassifyMergeCommand.RunAsync(rest, Console.Out),
+    ["extract", .. var rest] => await ExtractCommand.RunAsync(rest, Console.Error),
+    ["batches", .. var rest] => await BatchesCommand.RunAsync(rest, Console.Out),
+    ["prune", .. var rest] => await PruneCommand.RunAsync(rest, Console.Out),
+    ["render", .. var rest] => await RenderCommand.RunAsync(rest, Console.Error),
+    _ => PrintUsage(),
+};
+
+static int PrintUsage()
+{
+    Console.Error.WriteLine(CandidatesCommand.Usage);
+    Console.Error.WriteLine(ClassifyBatchesCommand.Usage);
+    Console.Error.WriteLine(ClassifyMergeCommand.Usage);
+    Console.Error.WriteLine(ExtractCommand.Usage);
+    Console.Error.WriteLine(BatchesCommand.Usage);
+    Console.Error.WriteLine(PruneCommand.Usage);
+    Console.Error.WriteLine(RenderCommand.Usage);
+    return 1;
+}

package/template/.claude/skills/logical-components/scripts/LogicalComponents/ProjectFilters.cs

@@ -0,0 +1,76 @@
+using System.Text.RegularExpressions;
+
+namespace LogicalComponents;
+
+/// <summary>
+/// Pure rules for which loaded projects the extractor keeps: no test projects, and one project per
+/// multi-targeted csproj. Kept free of Roslyn types so they are unit-testable from plain strings.
+/// </summary>
+public static partial class ProjectFilters
+{
+    /// <summary>
+    /// A test project lives under a <c>tests</c>/<c>test</c> folder, is named like one
+    /// (<c>.Tests</c>, <c>.UnitTests</c>, <c>.IntegrationTests</c>, <c>.Test</c>, <c>.Specs</c>), or its project
+    /// file carries a test marker (test SDK, <c>IsTestProject</c>, or a test-framework package).
+    /// Test-support libraries such as <c>Foo.Testing</c> are deliberately kept: nothing here can tell them apart
+    /// from source, and their types can be excluded through config.
+    /// </summary>
+    public static bool IsTestProject(string relativePath, string projectFileText)
+    {
+        var segments = relativePath.Split('/', '\\');
+        if (segments.Any(s => s.Equals("tests", StringComparison.OrdinalIgnoreCase)
+                || s.Equals("test", StringComparison.OrdinalIgnoreCase)))
+        {
+            return true;
+        }
+
+        return TestProjectName().IsMatch(Path.GetFileNameWithoutExtension(relativePath))
+            || TestProjectMarker().IsMatch(projectFileText);
+    }
+
+    /// <summary>
+    /// Orders the target framework in a loaded multi-target project name such as <c>Foo(net10.0)</c>.
+    /// Families rank .NET Framework &lt; netstandard &lt; netcoreapp &lt; net5+; versions order within a family.
+    /// </summary>
+    public static (int Family, Version Version) TargetFrameworkRank(string loadedProjectName)
+    {
+        var match = TargetFrameworkSuffix().Match(loadedProjectName);
+        if (!match.Success)
+        {
+            return (0, new Version(0, 0));
+        }
+
+        // Drop an OS suffix: net9.0-windows ranks as net9.0.
+        var tfm = match.Groups["tfm"].Value.ToLowerInvariant().Split('-')[0];
+        return tfm switch
+        {
+            _ when tfm.StartsWith("netstandard") => (1, ParseVersion(tfm["netstandard".Length..])),
+            _ when tfm.StartsWith("netcoreapp") => (2, ParseVersion(tfm["netcoreapp".Length..])),
+            _ when tfm.Contains('.') => (3, ParseVersion(tfm["net".Length..])),
+            // .NET Framework monikers pack the version into digits: net472 is 4.7.2.
+            _ => (0, ParseVersion(string.Join('.', tfm["net".Length..].ToCharArray()))),
+        };
+    }
+
+    /// <summary><c>Foo(net10.0)</c> becomes <c>Foo</c>; a name without a framework suffix is returned as-is.</summary>
+    public static string StripTargetFramework(string loadedProjectName)
+    {
+        var match = TargetFrameworkSuffix().Match(loadedProjectName);
+        return match.Success ? match.Groups["name"].Value : loadedProjectName;
+    }
+
+    private static Version ParseVersion(string text) =>
+        Version.TryParse(text.Contains('.') ? text : text + ".0", out var version) ? version : new Version(0, 0);
+
+    // Case-sensitive on purpose: "Foo.Contest" and "Latest.Feeds" must not look like test projects.
+    [GeneratedRegex(@"\.\w*Tests?$|\.Specs?$")]
+    private static partial Regex TestProjectName();
+
+    [GeneratedRegex(
+        @"<IsTestProject>\s*true\s*</IsTestProject>|Sdk=""MSTest\.Sdk|Include=""(Microsoft\.NET\.Test\.Sdk|xunit|xunit\.v3|xunit\.core|xunit\.v3\.core|NUnit|MSTest|MSTest\.TestFramework|Microsoft\.Testing\.Platform)""",
+        RegexOptions.IgnoreCase)]
+    private static partial Regex TestProjectMarker();
+
+    [GeneratedRegex(@"^(?<name>.+)\((?<tfm>net[^)]*)\)$")]
+    private static partial Regex TargetFrameworkSuffix();
+}

package/template/.claude/skills/logical-components/scripts/LogicalComponents/PruneCommand.cs

@@ -0,0 +1,132 @@
+using System.Text.Json;
+
+namespace LogicalComponents;
+
+/// <summary>
+/// <c>prune --resp &lt;dir&gt; --verify &lt;dir&gt; --out &lt;dir&gt;</c>: applies the verifier agents' verdicts. For every
+/// <c>resp/batch-NN.json</c> it reads <c>verify/batch-NN.json</c> — <c>{ "&lt;id&gt;": [ { "item": 1, "supported": true,
+/// "reason": "..." } ] }</c> — and writes the batch without its unsupported items to <c>--out</c>. The agents' files are
+/// never edited, so pruning is repeatable. Every item needs exactly one verdict: an unjudged claim is not verified, so
+/// any gap fails the step (exit 3) before anything is written. Exit codes: 0 written, 1 usage, 3 verdicts incomplete.
+/// </summary>
+public static class PruneCommand
+{
+    public const string Usage = "usage: LogicalComponents prune --resp <dir> --verify <dir> --out <dir>";
+
+    public sealed record Verdict(int Item, bool Supported, string? Reason);
+
+    private static readonly JsonSerializerOptions ReadOptions = new()
+    {
+        PropertyNameCaseInsensitive = true,
+        ReadCommentHandling = JsonCommentHandling.Skip,
+        AllowTrailingCommas = true,
+        AllowDuplicateProperties = false,
+    };
+
+    public static async Task<int> RunAsync(string[] args, TextWriter output)
+    {
+        if (args is not ["--resp", var respDir, "--verify", var verifyDir, "--out", var outDir]
+            || !Directory.Exists(respDir) || !Directory.Exists(verifyDir))
+        {
+            await output.WriteLineAsync(Usage);
+            return 1;
+        }
+
+        var problems = new List<string>();
+        var pruned = new List<(string File, SortedDictionary<string, List<Responsibility>> Kept)>();
+        var removed = new List<string>();
+        var emptied = new List<string>();
+
+        foreach (var respFile in Directory.EnumerateFiles(respDir, "batch-*.json").Order(StringComparer.Ordinal))
+        {
+            var name = Path.GetFileName(respFile);
+            var batch = ResponsibilityBatches.Load([respFile], ReadOptions);
+            problems.AddRange(batch.Problems);
+            var verdicts = ReadVerdicts(Path.Combine(verifyDir, name), name, problems);
+            if (verdicts is null)
+            {
+                continue;
+            }
+
+            var kept = new SortedDictionary<string, List<Responsibility>>(StringComparer.Ordinal);
+            foreach (var (id, items) in batch.Responsibilities.OrderBy(r => r.Key, StringComparer.Ordinal))
+            {
+                var judged = verdicts.GetValueOrDefault(id) ?? [];
+                problems.AddRange(judged.Where(v => v.Item < 1 || v.Item > items.Count)
+                    .Select(v => $"{id}[{v.Item}]: verdict for an item that does not exist ({name})"));
+
+                kept[id] = [];
+                for (var item = 1; item <= items.Count; item++)
+                {
+                    var forItem = judged.Where(v => v.Item == item).ToList();
+                    if (forItem.Count != 1)
+                    {
+                        problems.Add($"{id}[{item}]: {(forItem.Count == 0 ? "no verdict" : "more than one verdict")} ({name})");
+                    }
+                    else if (forItem[0].Supported)
+                    {
+                        kept[id].Add(items[item - 1]);
+                    }
+                    else
+                    {
+                        removed.Add($"removed {id}[{item}]: {forItem[0].Reason ?? "(no reason given)"}");
+                    }
+                }
+
+                if (items.Count > 0 && kept[id].Count == 0)
+                {
+                    emptied.Add($"empty {id}: every responsibility was unsupported");
+                }
+            }
+
+            problems.AddRange(verdicts.Keys.Where(id => !batch.Responsibilities.ContainsKey(id))
+                .Order(StringComparer.Ordinal)
+                .Select(id => $"{id}: verdicts for a component the batch does not answer ({name})"));
+            pruned.Add((name, kept));
+        }
+
+        if (problems.Count > 0)
+        {
+            foreach (var problem in problems)
+            {
+                await output.WriteLineAsync(problem);
+            }
+
+            return 3;
+        }
+
+        Directory.CreateDirectory(outDir);
+        foreach (var (file, kept) in pruned)
+        {
+            await File.WriteAllBytesAsync(Path.Combine(outDir, file), ComponentsFile.ToJson(kept));
+        }
+
+        foreach (var line in removed.Concat(emptied))
+        {
+            await output.WriteLineAsync(line);
+        }
+
+        await output.WriteLineAsync($"{removed.Count} removed, {emptied.Count} empty");
+        return 0;
+    }
+
+    private static Dictionary<string, List<Verdict>>? ReadVerdicts(string path, string name, List<string> problems)
+    {
+        if (!File.Exists(path))
+        {
+            problems.Add($"{name}: no verdict file");
+            return null;
+        }
+
+        try
+        {
+            var verdicts = JsonSerializer.Deserialize<Dictionary<string, List<Verdict>?>>(File.ReadAllText(path), ReadOptions) ?? [];
+            return verdicts.ToDictionary(v => v.Key, v => v.Value ?? [], StringComparer.Ordinal);
+        }
+        catch (Exception e) when (e is IOException or UnauthorizedAccessException or JsonException)
+        {
+            problems.Add($"{name}: not a valid verdict file ({e.Message})");
+            return null;
+        }
+    }
+}