@phuc1403/musketeer 0.11.0 → 0.12.0

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

@@ -0,0 +1,72 @@
+using System.Text;
+
+namespace LogicalComponents;
+
+/// <summary>
+/// CommonMark code-span parsing for <see cref="ResponsibilityValidation"/>'s plain-text check: a backtick run of
+/// length n opens a code span, which closes at the next run of exactly length n (a run of a different length inside is
+/// literal content; a run with no matching close is an unclosed delimiter, not a span). A naive `` `[^`]*` `` match
+/// gets this wrong for an escaped or mismatched backtick, which could let HTML or a link hide inside what looks like,
+/// but is not, a real code span.
+/// </summary>
+public static class MarkdownCodeSpans
+{
+    /// <summary>The text with every real code span removed, and whether any backtick run was left unmatched.</summary>
+    public static (string Outside, bool Unclosed) Strip(string text)
+    {
+        var outside = new StringBuilder();
+        var unclosed = false;
+        var i = 0;
+        while (i < text.Length)
+        {
+            if (text[i] != '`')
+            {
+                outside.Append(text[i]);
+                i++;
+                continue;
+            }
+
+            var openStart = i;
+            while (i < text.Length && text[i] == '`')
+            {
+                i++;
+            }
+
+            var openLength = i - openStart;
+            var closeStart = -1;
+            var j = i;
+            while (j < text.Length)
+            {
+                if (text[j] != '`')
+                {
+                    j++;
+                    continue;
+                }
+
+                var runStart = j;
+                while (j < text.Length && text[j] == '`')
+                {
+                    j++;
+                }
+
+                if (j - runStart == openLength)
+                {
+                    closeStart = runStart;
+                    break;
+                }
+            }
+
+            if (closeStart >= 0)
+            {
+                i = closeStart + openLength;
+            }
+            else
+            {
+                unclosed = true;
+                outside.Append('`', openLength);
+            }
+        }
+
+        return (outside.ToString(), unclosed);
+    }
+}

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

@@ -61,13 +61,18 @@ public static class MarkdownRenderer
         return md.ToString();
     }
 
-    // Mermaid node labels are double-quoted; a literal quote is written as an entity.
-    private static string Escape(string label) => label.Replace("\"", "#quot;");
+    // Mermaid node labels are double-quoted; a literal quote is written as an entity. Angle brackets are escaped the
+    // same way: some renderers treat a label as HTML, and an unescaped `<` in a type or module name could otherwise
+    // inject markup into the diagram.
+    private static string Escape(string label) => label.Replace("\"", "#quot;").Replace("<", "#lt;").Replace(">", "#gt;");
 
     /// <summary>
-    /// A Mermaid-safe node id: prefixed so a component called <c>end</c>, <c>graph</c> or <c>class</c> is never read as a
-    /// keyword, and reduced to letters, digits and underscores so a module name with spaces cannot break a line.
+    /// A Mermaid-safe node id: prefixed so a component called <c>end</c>, <c>graph</c> or <c>class</c> is never read as
+    /// a keyword, and every character that is not an ASCII letter or digit - including a literal underscore, so the
+    /// escape below cannot collide with one already in the id - is replaced by <c>_x{hex}_</c>. That makes the mapping
+    /// injective (two different ids always get two different node ids), unlike collapsing every such character to a
+    /// single <c>_</c>, which let ids as different as "My Module_Queue" and "My-Module.Queue" collide.
     /// </summary>
-    private static string NodeId(string id) =>
-        "n_" + new string(id.Select(c => char.IsAsciiLetterOrDigit(c) ? c : '_').ToArray());
+    private static string NodeId(string id) => "n_" + string.Concat(
+        id.Select(c => char.IsAsciiLetterOrDigit(c) ? c.ToString() : $"_x{(int)c:x}_"));
 }

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

@@ -22,10 +22,19 @@ namespace LogicalComponents;
 /// </summary>
 public sealed class MemberUseResolution(LoadedWorkspace loaded, IReadOnlySet<string> components, PortResolution ports)
 {
+    // How many seen-through hops one chain may follow before it is cut off with a warning: real helper chains never
+    // run this deep, but a generic helper that instantiates itself one level deeper at every hop (Nest<T> calling
+    // Nest<List<T>>) never revisits the same (member, bindings) pair, so the cycle guard below never catches it and the
+    // walk would otherwise recurse until the process stack overflows.
+    private const int MaxWalkDepth = 200;
+
     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);
+    /// <summary>
+    /// The edges a component's code leads to, the helper code it runs on the way (sorted, distinct), and warnings about
+    /// coupling the walk could not fully resolve.
+    /// </summary>
+    public sealed record Resolution(List<RawEdge> Edges, List<SourceSpan> Reaches, List<string> Warnings);
 
     // 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 = [];
@@ -33,24 +42,28 @@ public sealed class MemberUseResolution(LoadedWorkspace loaded, IReadOnlySet<str
 
     /// <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.
+    /// component and the base classes whose code counts as its own: uses of those are not coupling. <paramref name="map"/>
+    /// binds the type parameters of any base class among <paramref name="uses"/>' declaring types to what the component
+    /// supplies as its base class construction, so a generic base's own seam calls resolve to the right construction.
     /// </summary>
     public async Task<Resolution> ResolveAsync(
-        string from, IReadOnlySet<string> self, IEnumerable<MemberUses.MemberUse> uses, CancellationToken cancellationToken)
+        string from, IReadOnlySet<string> self, IEnumerable<MemberUses.MemberUse> uses, TypeMap map,
+        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);
+            await ResolveUseAsync(use.Member, use.Kind, [], use.File, use.Line, map, walk, cancellationToken);
         }
 
         return new Resolution(
             walk.Edges,
-            walk.Reaches.OrderBy(s => s.File, StringComparer.Ordinal).ThenBy(s => s.Start).ThenBy(s => s.End).ToList());
+            walk.Reaches.OrderBy(s => s.File, StringComparer.Ordinal).ThenBy(s => s.Start).ThenBy(s => s.End).ToList(),
+            walk.Warnings.Order(StringComparer.Ordinal).ToList());
     }
 
     // One component's walk: members already seen through (for the same type bindings) are not walked again, which also
-    // ends cycles.
+    // ends cycles. Depth guards the chains a cycle can't catch (see MaxWalkDepth).
     private sealed class Walk(string from, IReadOnlySet<string> self)
     {
         public string From { get; } = from;
@@ -58,6 +71,10 @@ public sealed class MemberUseResolution(LoadedWorkspace loaded, IReadOnlySet<str
         public HashSet<string> Visited { get; } = new(StringComparer.Ordinal);
         public List<RawEdge> Edges { get; } = [];
         public HashSet<SourceSpan> Reaches { get; } = [];
+        public HashSet<string> Warnings { get; } = new(StringComparer.Ordinal);
+        public int Depth { get; set; }
+
+        public void Warn(string message) => Warnings.Add(message);
     }
 
     private async Task ResolveUseAsync(
@@ -96,7 +113,21 @@ public sealed class MemberUseResolution(LoadedWorkspace loaded, IReadOnlySet<str
 
         if (EdgeExtraction.IsSeam(declaring) && !member.IsStatic && kind != EdgeExtraction.New)
         {
-            foreach (var implementation in await ports.ImplementationsAsync(declaring, cancellationToken))
+            // A concrete, non-virtual member of an abstract class cannot be overridden: it runs as written for every
+            // subclass (or none), so it is this walk's own behaviour rather than a per-implementation dispatch.
+            if (declaring.TypeKind == TypeKind.Class && !IsOverridable(member))
+            {
+                await SeeThroughAsync(member, kind, via.Add(SymbolNames.FullName(declaring)), file, line, map, walk, cancellationToken);
+                return;
+            }
+
+            var implementations = await ports.ImplementationsAsync(declaring, cancellationToken);
+            if (implementations.Count == 0 && declaring.TypeKind == TypeKind.Class)
+            {
+                walk.Warn($"{SymbolNames.FullName(declaring.OriginalDefinition)}.{member.Name} has no concrete subclass in the repo");
+            }
+
+            foreach (var implementation in implementations)
             {
                 if (SeamDispatch.ImplementationOf(implementation, declaring, member) is not { } runs)
                 {
@@ -106,18 +137,22 @@ public sealed class MemberUseResolution(LoadedWorkspace loaded, IReadOnlySet<str
                 // 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);
+                    await SeeThroughAsync(runs, kind, via.Add(SymbolNames.FullName(declaring)), file, line, map, walk, cancellationToken);
                 }
                 else
                 {
-                    await ResolveUseAsync(runs, kind, via.Add(declaring.Name), file, line, TypeMap.Empty, walk, cancellationToken);
+                    // Bind the implementation's own type parameters (an open-generic decorator) and the resolved
+                    // method's own type parameters (a generic method declared on the seam) to what this use actually
+                    // supplies, so a seam the implementation calls in turn resolves to the right construction too.
+                    var binding = SeamDispatch.BindingFor(implementation, declaring, member, runs, map);
+                    await ResolveUseAsync(runs, kind, via.Add(SymbolNames.FullName(declaring)), file, line, binding, walk, cancellationToken);
                 }
             }
 
             return;
         }
 
-        await SeeThroughAsync(member, kind, via.Add(owner.Name), file, line, map, walk, cancellationToken);
+        await SeeThroughAsync(member, kind, via.Add(SymbolNames.FullName(owner)), file, line, map, walk, cancellationToken);
     }
 
     private async Task SeeThroughAsync(
@@ -145,26 +180,60 @@ public sealed class MemberUseResolution(LoadedWorkspace loaded, IReadOnlySet<str
             return;
         }
 
-        var (roots, runsImplicitBase) = kind == EdgeExtraction.New && member is IMethodSymbol constructor
-            ? WalkRoots.Construction(constructor)
-            : (WalkRoots.Body(member), false);
-        Record(roots, walk);
+        // A cycle that never repeats a (member, bindings) pair (a generic helper instantiating itself one level
+        // deeper at every hop) would otherwise recurse until the process stack overflows: cut it off instead.
+        if (walk.Depth >= MaxWalkDepth)
+        {
+            walk.Warn($"{walk.From}: coupling walk stopped at depth {MaxWalkDepth} following {member.Name}, possible unbounded generic recursion");
+            return;
+        }
 
-        foreach (var root in roots)
+        walk.Depth++;
+        try
         {
-            foreach (var use in await UsesAsync(root, cancellationToken))
+            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)
             {
-                await ResolveUseAsync(use.Member, use.Kind, via, file, line, inner, walk, cancellationToken);
+                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)
+            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 static constructor runs once, lazily, before the type's first static member use or instantiation:
+            // consistent with a static field's own initializer, which is already walked wherever that field is read.
+            if ((kind == EdgeExtraction.Static || kind == EdgeExtraction.New)
+                && member.ContainingType?.OriginalDefinition.StaticConstructors.FirstOrDefault(c => !c.IsImplicitlyDeclared)
+                    is { } staticConstructor)
+            {
+                await ResolveUseAsync(staticConstructor, EdgeExtraction.Call, via, file, line, inner, walk, cancellationToken);
+            }
+        }
+        finally
         {
-            await ResolveUseAsync(baseConstructor, EdgeExtraction.New, via, file, line, inner, walk, cancellationToken);
+            walk.Depth--;
         }
     }
 
+    /// <summary>A method, property or event that a subclass could give a different body: dispatch, not fixed code.</summary>
+    private static bool IsOverridable(ISymbol member) => member switch
+    {
+        IMethodSymbol method => method.IsVirtual || method.IsAbstract || method.IsOverride,
+        IPropertySymbol property => property.IsVirtual || property.IsAbstract || property.IsOverride,
+        IEventSymbol @event => @event.IsVirtual || @event.IsAbstract || @event.IsOverride,
+        _ => false,
+    };
+
     // 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)
     {

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

@@ -8,17 +8,23 @@ namespace LogicalComponents;
 /// 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"/>.
+/// 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 are skipped.</summary>
+    /// <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)
     {
@@ -33,7 +39,10 @@ public static class MemberUses
 
             var model = await document.GetSemanticModelAsync(cancellationToken)
                 ?? throw new InvalidOperationException($"No semantic model for {file}");
-            foreach (var node in root.DescendantNodesAndSelf())
+
+            // 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)));
@@ -46,6 +55,7 @@ public static class MemberUses
     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)
         {
@@ -63,7 +73,7 @@ public static class MemberUses
                 }
 
                 break;
-            case ElementAccessExpressionSyntax when Symbol() is IPropertySymbol indexer:
+            case ElementAccessExpressionSyntax or ElementBindingExpressionSyntax when Symbol() is IPropertySymbol indexer:
                 foreach (var accessor in AccessorsThatRun(indexer, node))
                 {
                     yield return (accessor, EdgeExtraction.Call);
@@ -75,9 +85,75 @@ public static class MemberUses
                 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);
+            // 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;
+            }
         }
     }
 

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

@@ -0,0 +1,55 @@
+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/ProjectFilters.cs

@@ -62,8 +62,9 @@ public static partial class ProjectFilters
     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?$")]
+    // 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(

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

@@ -6,8 +6,10 @@ namespace LogicalComponents;
 /// <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.
+/// 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
 {
@@ -15,6 +17,11 @@ public static class PruneCommand
 
     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,
@@ -118,15 +125,40 @@ public static class PruneCommand
             return null;
         }
 
+        Dictionary<string, List<RawVerdict?>?>? raw;
         try
         {
-            var verdicts = JsonSerializer.Deserialize<Dictionary<string, List<Verdict>?>>(File.ReadAllText(path), ReadOptions) ?? [];
-            return verdicts.ToDictionary(v => v.Key, v => v.Value ?? [], StringComparer.Ordinal);
+            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;
     }
 }