@phuc1403/musketeer 0.12.1 → 0.15.0

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

@@ -1,231 +0,0 @@
-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 or conditional-access indexer, the enumerator, deconstruction and <c>MoveNext</c>/<c>Current</c>
-/// a <c>foreach</c> runs, the <c>Add</c> a collection initializer element runs, a deconstruction assignment's
-/// <c>Deconstruct</c>, and the <c>GetAwaiter</c>/<c>IsCompleted</c>/<c>GetResult</c> an <c>await</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. Attribute names are not uses: an attribute is metadata the compiler reads, not code the
-/// annotated member runs. 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, and nodes inside an
-    /// attribute list, 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}");
-
-            // An attribute name resolves to its constructor, but applying an attribute is not running code: never
-            // descend into an attribute list at all, so nothing inside one is ever read as a use.
-            foreach (var node in root.DescendantNodesAndSelf(descendant => descendant is not AttributeListSyntax))
-            {
-                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;
-        (ISymbol, string) AsUse(ISymbol member) => (member, member.IsStatic ? EdgeExtraction.Static : EdgeExtraction.Call);
-
-        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 or ElementBindingExpressionSyntax 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;
-            // A deconstruction assignment, `(a, b) = point;`: tried before the operator-assignment case above, but only
-            // claims the node when it is actually a deconstruction, so a plain or compound assignment still falls
-            // through to it.
-            case AssignmentExpressionSyntax assignment when DeconstructMethods(model.GetDeconstructionInfo(assignment)).ToList()
-                is { Count: > 0 } assignmentDeconstructs:
-                foreach (var method in assignmentDeconstructs)
-                {
-                    yield return AsUse(method);
-                }
-
-                break;
-            case CommonForEachStatementSyntax loop:
-                var info = model.GetForEachStatementInfo(loop);
-                foreach (var member in new ISymbol?[] { info.GetEnumeratorMethod, info.MoveNextMethod, info.CurrentProperty?.GetMethod })
-                {
-                    if (member is not null)
-                    {
-                        yield return AsUse(member);
-                    }
-                }
-
-                // foreach (var (a, b) in pairs): the per-element deconstruction, same as an explicit assignment's.
-                if (loop is ForEachVariableStatementSyntax deconstructingLoop)
-                {
-                    foreach (var method in DeconstructMethods(model.GetDeconstructionInfo(deconstructingLoop)))
-                    {
-                        yield return AsUse(method);
-                    }
-                }
-
-                break;
-            case InitializerExpressionSyntax initializer when initializer.IsKind(SyntaxKind.CollectionInitializerExpression):
-                foreach (var element in initializer.Expressions)
-                {
-                    if (model.GetCollectionInitializerSymbolInfo(element).Symbol is IMethodSymbol add)
-                    {
-                        yield return AsUse(add);
-                    }
-                }
-
-                break;
-            case AwaitExpressionSyntax awaitExpression:
-                var awaited = model.GetAwaitExpressionInfo(awaitExpression);
-                foreach (var member in new ISymbol?[] { awaited.GetAwaiterMethod, awaited.IsCompletedProperty?.GetMethod, awaited.GetResultMethod })
-                {
-                    if (member is not null)
-                    {
-                        yield return AsUse(member);
-                    }
-                }
-
-                break;
-        }
-    }
-
-    /// <summary>The Deconstruct methods a deconstruction runs, including any nested tuple/pattern's own.</summary>
-    private static IEnumerable<IMethodSymbol> DeconstructMethods(DeconstructionInfo info)
-    {
-        if (info.Method is { } method)
-        {
-            yield return method;
-        }
-
-        foreach (var nested in info.Nested)
-        {
-            foreach (var method2 in DeconstructMethods(nested))
-            {
-                yield return method2;
-            }
-        }
-    }
-
-    /// <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/PlainText.cs

@@ -1,55 +0,0 @@
-using System.Globalization;
-using System.Text;
-
-namespace LogicalComponents;
-
-/// <summary>
-/// The unicode rule shared by every short string an agent hands back that is stored verbatim or shown at a review
-/// gate: a classify verdict's <c>reason</c> (<see cref="ClassifyMergeCommand"/>) and a responsibility's <c>text</c>
-/// (<see cref="ResponsibilityValidation"/>). Neither may contain a character that could hide something from a
-/// reviewer or a renderer - a bidi override, a zero-width character, or one that fakes a line break.
-/// </summary>
-public static class PlainText
-{
-    /// <summary>
-    /// True for text containing a Unicode category that must never appear in plain text stored or shown verbatim:
-    /// control (Cc), format (Cf - includes bidi overrides like U+202E and zero-width characters), line/paragraph
-    /// separators (Zl/Zp - could fake a second line), private-use (Co), or a lone surrogate (Cs).
-    /// </summary>
-    public static bool HasDisallowedUnicode(string text)
-    {
-        for (var i = 0; i < text.Length; i++)
-        {
-            var c = text[i];
-            if (char.IsHighSurrogate(c))
-            {
-                if (i + 1 >= text.Length || !char.IsLowSurrogate(text[i + 1]))
-                {
-                    return true; // lone high surrogate
-                }
-
-                if (IsBannedCategory(Rune.GetUnicodeCategory(new Rune(c, text[i + 1]))))
-                {
-                    return true;
-                }
-
-                i++;
-                continue;
-            }
-
-            if (char.IsLowSurrogate(c) || IsDisallowed(c))
-            {
-                return true;
-            }
-        }
-
-        return false;
-    }
-
-    /// <summary>True for one UTF-16 code unit in a category <see cref="HasDisallowedUnicode"/> rejects.</summary>
-    public static bool IsDisallowed(char c) => IsBannedCategory(CharUnicodeInfo.GetUnicodeCategory(c));
-
-    private static bool IsBannedCategory(UnicodeCategory category) => category is UnicodeCategory.Control
-        or UnicodeCategory.Format or UnicodeCategory.LineSeparator or UnicodeCategory.ParagraphSeparator
-        or UnicodeCategory.PrivateUse or UnicodeCategory.Surrogate;
-}

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

@@ -1,75 +0,0 @@
-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

@@ -1,27 +0,0 @@
-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

@@ -1,77 +0,0 @@
-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);
-
-    // Segment-based and case-sensitive on purpose: "Foo.Contest", "Latest.Feeds", "Net.SpeedTest" and
-    // "Experiments.ABTest" must not look like test projects; only these exact last-segment suffixes do.
-    [GeneratedRegex(@"\.(Test|Tests|UnitTests|IntegrationTests|FunctionalTests|Spec|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

@@ -1,164 +0,0 @@
-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, a
-/// null verdict entry or one missing <c>supported</c> is malformed (never silently "not supported"), so any gap or
-/// malformed entry fails the step (exit 3) before anything is written. Exit codes: 0 written, 1 usage, 3 verdicts
-/// incomplete or malformed.
-/// </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);
-
-    // Supported is nullable only for reading: a verifier file missing it, or a null array entry, is malformed input
-    // (exit 3) rather than a silent "not supported". Verdict above keeps Supported non-nullable for every other use,
-    // once ReadVerdicts has confirmed it is actually there.
-    private sealed record RawVerdict(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;
-        }
-
-        Dictionary<string, List<RawVerdict?>?>? raw;
-        try
-        {
-            raw = JsonSerializer.Deserialize<Dictionary<string, List<RawVerdict?>?>>(File.ReadAllText(path), ReadOptions);
-        }
-        catch (Exception e) when (e is IOException or UnauthorizedAccessException or JsonException)
-        {
-            problems.Add($"{name}: not a valid verdict file ({e.Message})");
-            return null;
-        }
-
-        var clean = new Dictionary<string, List<Verdict>>(StringComparer.Ordinal);
-        foreach (var (id, items) in raw ?? [])
-        {
-            var kept = new List<Verdict>();
-            foreach (var verdict in items ?? [])
-            {
-                if (verdict is null)
-                {
-                    problems.Add($"{id}: a null verdict entry ({name})");
-                }
-                else if (verdict.Supported is not { } supported)
-                {
-                    problems.Add($"{id}[{verdict.Item}]: verdict is missing 'supported' ({name})");
-                }
-                else
-                {
-                    kept.Add(new Verdict(verdict.Item, supported, verdict.Reason));
-                }
-            }
-
-            clean[id] = kept;
-        }
-
-        return clean;
-    }
-}