@phuc1403/musketeer 0.11.0 → 0.12.0

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

@@ -0,0 +1,37 @@
+namespace LogicalComponents.Tests;
+
+/// <summary>The batches command end to end: malformed or extreme input fails cleanly instead of crashing.</summary>
+public class BatchesCommandTests : IDisposable
+{
+    private readonly DirectoryInfo _work = Directory.CreateTempSubdirectory("lc-batches-cmd-");
+
+    public void Dispose() => _work.Delete(recursive: true);
+
+    private string PathOf(string relative) => Path.Combine(_work.FullName, relative);
+
+    [Fact]
+    public async Task An_empty_components_json_is_an_error_not_a_crash()
+    {
+        File.WriteAllText(PathOf("components.json"), "{}");
+        var output = new StringWriter();
+
+        var exit = await BatchesCommand.RunAsync(
+            ["--components", PathOf("components.json"), "--agents", "9", "--out", PathOf("batches")], output);
+
+        Assert.Equal(2, exit);
+        Assert.Contains(PathOf("components.json"), output.ToString());
+    }
+
+    [Fact]
+    public async Task An_enormous_agent_count_does_not_crash()
+    {
+        File.WriteAllBytes(PathOf("components.json"), ComponentsFile.Serialize(RenderTestData.Extraction));
+        var output = new StringWriter();
+
+        var exit = await BatchesCommand.RunAsync(
+            ["--components", PathOf("components.json"), "--agents", int.MaxValue.ToString(), "--out", PathOf("batches")], output);
+
+        Assert.Equal(0, exit);
+        Assert.True(File.Exists(Path.Combine(PathOf("batches"), "batch-01.json")));
+    }
+}

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

@@ -31,4 +31,29 @@ public class CandidatesCommandTests(SampleAppWorkspace sample)
 
         Assert.Equal(["Sample.Infrastructure.Mailer"], error.Types);
     }
+
+    [Fact]
+    public async Task Unknown_option_prints_usage_and_exits_1()
+    {
+        var errors = new StringWriter();
+
+        var exitCode = await CandidatesCommand.RunAsync(["repo", "--bogus"], errors);
+
+        Assert.Equal(1, exitCode);
+        Assert.Contains(CandidatesCommand.Usage, errors.ToString());
+    }
+
+    [Fact]
+    public async Task Solution_option_is_parsed_and_passed_through_to_the_loader()
+    {
+        var errors = new StringWriter();
+        var missing = Path.Combine(Path.GetTempPath(), "lc-does-not-exist-" + Guid.NewGuid());
+
+        var exitCode = await CandidatesCommand.RunAsync([missing, "--solution", "custom.slnx", "--out", "out.json"], errors);
+
+        // --solution and --out both parsed fine (no usage error); it fails later because repoPath itself is missing,
+        // proving the flag reached WorkspaceLoader.LoadAsync rather than being rejected as an unknown option.
+        Assert.Equal(2, exitCode);
+        Assert.Contains(missing, errors.ToString());
+    }
 }

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

@@ -110,6 +110,7 @@ public class ClassifyCommandsTests : IDisposable
         { Verdict("A.One", "maybe"), "batch-01.json: A.One: verdict must be component or helper" },
         { Verdict("A.One", "helper", ""), "batch-01.json: A.One: reason is empty" },
         { Verdict("A.One", "helper", "x\\nkept Evil: already classified"), "batch-01.json: A.One: reason has control characters" },
+        { Verdict("A.One", "helper", "Renamed ‮exe.txt to txt.exe"), "batch-01.json: A.One: reason has control characters" },
         { Verdict("A.One", "helper", new string('x', 201)), "batch-01.json: A.One: reason is 201 characters; keep it under 200" },
         { Verdict("A.One", "helper", cite: "src/A.One.cs:12"), "batch-01.json: A.One: cite 'src/A.One.cs:12' is not inside its declaration" },
         { Verdict("A.One", "helper", cite: "src/Other.cs:2"), "batch-01.json: A.One: cite 'src/Other.cs:2' is not inside its declaration" },
@@ -134,6 +135,78 @@ public class ClassifyCommandsTests : IDisposable
         Assert.False(File.Exists(PathOf("repo/logical-components.json")));
     }
 
+    [Fact]
+    public async Task A_verdict_for_a_type_the_config_already_classifies_fails_the_merge_without_touching_the_config()
+    {
+        // Simulates a stale candidates.json: classify-batches sent A.One as unclassified (the config had no answer
+        // for it yet), but by the time this round is merged the config already classifies it (an earlier round
+        // classified it in the meantime, so this verdict must not overwrite the reviewed entry).
+        await BatchAsync(1, Candidate("A.One", "unclassified"));
+        var updated = """{ "components": ["A.One"], "helpers": {} }""";
+        File.WriteAllText(PathOf("repo/logical-components.json"), updated);
+        WriteVerdicts("batch-01.json", Verdict("A.One", "helper", "Value object."));
+        var output = new StringWriter();
+
+        var exit = await MergeAsync(output);
+
+        Assert.Equal(3, exit);
+        Assert.Contains("batch-01.json: A.One: already classified in logical-components.json; re-run candidates", output.ToString());
+        Assert.Equal(updated, File.ReadAllText(PathOf("repo/logical-components.json")));
+    }
+
+    [Fact]
+    public async Task A_malformed_batch_file_fails_the_merge_cleanly_instead_of_crashing()
+    {
+        await BatchAsync(1, Candidate("A.One", "unclassified"));
+        File.WriteAllText(PathOf("batches/batch-01.json"), "{ not json");
+        WriteVerdicts("batch-01.json", Verdict("A.One", "helper"));
+        var output = new StringWriter();
+
+        var exit = await MergeAsync(output);
+
+        Assert.Equal(2, exit);
+        Assert.Contains("batch-01.json", output.ToString());
+        Assert.False(File.Exists(PathOf("repo/logical-components.json")));
+    }
+
+    [Fact]
+    public async Task Stale_candidates_already_classified_in_the_config_are_skipped_when_batching()
+    {
+        File.WriteAllText(PathOf("repo/logical-components.json"), """{ "components": ["A.One"], "helpers": {} }""");
+        File.WriteAllBytes(PathOf("candidates.json"), ComponentsFile.ToJson(new CandidatesCommand.CandidatesFile(
+            [Candidate("A.One", "unclassified"), Candidate("A.Two", "unclassified")], [])));
+        var output = new StringWriter();
+
+        var exit = await ClassifyBatchesCommand.RunAsync(
+            ["--candidates", PathOf("candidates.json"), "--agents", "9", "--repo", PathOf("repo"), "--out", PathOf("batches")], output);
+
+        Assert.Equal(0, exit);
+        var text = File.ReadAllText(PathOf("batches/batch-01.json"));
+        Assert.DoesNotContain("A.One", text);
+        Assert.Contains("A.Two", text);
+        Assert.StartsWith("1 unclassified candidates in 1 batches", output.ToString());
+    }
+
+    [Fact]
+    public async Task An_empty_candidates_json_fails_batching_instead_of_crashing()
+    {
+        File.WriteAllText(PathOf("candidates.json"), "{}");
+        var output = new StringWriter();
+
+        var exit = await ClassifyBatchesCommand.RunAsync(
+            ["--candidates", PathOf("candidates.json"), "--agents", "9", "--repo", PathOf("repo"), "--out", PathOf("batches")], output);
+
+        Assert.Equal(2, exit);
+    }
+
+    [Fact]
+    public async Task A_malformed_repo_config_fails_batching_cleanly()
+    {
+        File.WriteAllText(PathOf("repo/logical-components.json"), "{ not json");
+
+        Assert.Equal(2, await BatchAsync(9, Candidate("A.One", "unclassified")));
+    }
+
     [Fact]
     public async Task A_missing_verdict_file_and_a_stale_one_from_an_earlier_round_both_fail()
     {

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

@@ -61,6 +61,69 @@ public class ComponentDiscoveryTests(SampleAppWorkspace sample)
         Assert.DoesNotContain(result.Components, c => c.Type == "Sample.Infrastructure.Mailer");
     }
 
+    [Theory]
+    [InlineData("Foo.Application", "Application", "Foo")]
+    [InlineData("Foo.application", "Application", "Foo")]
+    [InlineData("Application", "Application", "Application")]
+    [InlineData("Infrastructure", "Infrastructure", "Infrastructure")]
+    [InlineData("infrastructure", "Infrastructure", "infrastructure")]
+    [InlineData("WorkerDwg.Export.Application", "Application", "Export")]
+    [InlineData("Sample.Infrastructure", "Infrastructure", "Sample")]
+    [InlineData("Foo.Domain", "Other", "Domain")]
+    public void LayerAndModule_accepts_bare_and_case_insensitive_layer_names(string projectName, string layer, string module)
+    {
+        Assert.Equal((layer, module), ComponentDiscovery.LayerAndModule(projectName));
+    }
+
+    [Fact]
+    public async Task Warns_naming_the_loaded_projects_when_none_matches_either_layer()
+    {
+        var repo = Directory.CreateTempSubdirectory("lc-no-layer-");
+        try
+        {
+            var project = Directory.CreateDirectory(Path.Combine(repo.FullName, "src", "Foo.Domain"));
+            File.WriteAllText(
+                Path.Combine(project.FullName, "Foo.Domain.csproj"),
+                """<Project Sdk="Microsoft.NET.Sdk"><PropertyGroup><TargetFramework>net10.0</TargetFramework></PropertyGroup></Project>""");
+            File.WriteAllText(
+                Path.Combine(project.FullName, "Widget.cs"),
+                "namespace Foo.Domain; public sealed class Widget { public string Name() => \"widget\"; }");
+
+            using var loaded = await WorkspaceLoader.LoadAsync(repo.FullName);
+            var result = await ComponentDiscovery.CandidatesAsync(loaded, TestContext.Current.CancellationToken);
+
+            Assert.Contains(result.Warnings, w => w.Contains("Foo.Domain") && w.Contains("Application") && w.Contains("Infrastructure"));
+            Assert.Empty(result.Candidates);
+        }
+        finally
+        {
+            repo.Delete(recursive: true);
+        }
+    }
+
+    [Fact]
+    public async Task Host_builder_setup_and_autofac_modules_are_composition_roots_not_candidates()
+    {
+        using var loaded = await WorkspaceLoader.LoadAsync(FixturePaths.CompositionRootApp);
+        var result = await ComponentDiscovery.CandidatesAsync(loaded, TestContext.Current.CancellationToken);
+        var types = result.Candidates.Select(c => c.Type).ToList();
+
+        Assert.Contains("Root.Application.RootGreeter", types);
+        Assert.DoesNotContain("Root.Application.HostBuilderExtensions", types);
+        Assert.DoesNotContain("Root.Application.RootAutofacModule", types);
+    }
+
+    [Fact]
+    public async Task Native_interop_methods_do_not_count_as_a_declared_body()
+    {
+        using var loaded = await WorkspaceLoader.LoadAsync(FixturePaths.CompositionRootApp);
+        var result = await ComponentDiscovery.CandidatesAsync(loaded, TestContext.Current.CancellationToken);
+        var types = result.Candidates.Select(c => c.Type).ToList();
+
+        Assert.DoesNotContain("Root.Application.ClassicPInvoke", types);
+        Assert.DoesNotContain("Root.Application.ModernPInvoke", types);
+    }
+
     [Fact]
     public async Task Config_entries_naming_no_candidate_are_warnings_not_failures()
     {

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

@@ -0,0 +1,188 @@
+namespace LogicalComponents.Tests;
+
+/// <summary>
+/// Coupling rules checked against the CouplingApp fixture (see its <c>logical-components.json</c> and
+/// <c>src/CouplingApp.Application/*.cs</c> for the classified types and the code each test exercises). SampleApp's own coupling
+/// assertions live in <see cref="CouplingExtractionTests"/>; this fixture exists so those existing candidate/edge
+/// counts never shift.
+/// </summary>
+[Collection(CouplingAppFixtureSolutions.Name)]
+public class CouplingAppExtractionTests(CouplingAppWorkspace coupling)
+{
+    private static readonly ExtractConfig FixtureConfig = ExtractConfig.Load(CouplingAppWorkspace.RepoRoot);
+
+    private Task<ExtractResult> ExtractAsync() =>
+        CouplingResolver.ExtractAsync(coupling.Loaded, FixtureConfig, TestContext.Current.CancellationToken);
+
+    [Fact]
+    public async Task A_generic_helper_that_instantiates_itself_deeper_at_every_call_does_not_overflow_the_stack()
+    {
+        // Nest<T>.Go(n) calls Nest<List<T>>.Go(n - 1): every recursive call binds T one level deeper, so the walk
+        // never revisits the same (member, bindings) pair and the cycle guard alone cannot stop it.
+        var result = await ExtractAsync();
+
+        Assert.Contains(
+            "CouplingApp.Application.NestRunning: coupling walk stopped at depth 200 following Go, "
+            + "possible unbounded generic recursion",
+            result.Warnings);
+    }
+
+    [Fact]
+    public async Task A_generic_method_declared_on_a_seam_binds_its_own_type_argument_behind_the_implementation()
+    {
+        // Dispatch.Send<T> (found through IDispatch) calls IHandler<T>.Handle: walking Send with T unbound would make
+        // IHandler<T> look like it matches every construction, reaching both Ping and Pong handlers.
+        var result = await ExtractAsync();
+
+        Assert.Contains(result.Edges, e => e.From == "GenericMethodDispatching" && e.To == "PingHandling");
+        Assert.DoesNotContain(result.Edges, e => e.From == "GenericMethodDispatching" && e.To == "PongHandling");
+    }
+
+    [Fact]
+    public async Task An_open_generic_decorator_wrapping_the_same_seam_keeps_its_type_argument_bound()
+    {
+        // Decorator<T> : IHandler<T> forwards to another IHandler<T>: walking it with T unbound would make the
+        // forwarded call look like it matches every construction too.
+        var result = await ExtractAsync();
+
+        Assert.Contains(result.Edges, e => e.From == "DecoratedDispatching" && e.To == "PingHandling");
+        Assert.DoesNotContain(result.Edges, e => e.From == "DecoratedDispatching" && e.To == "PongHandling");
+    }
+
+    [Fact]
+    public async Task A_generic_abstract_base_binds_its_type_parameter_to_what_the_subclass_supplies()
+    {
+        // HandlerBase<T>(IHandler<T> inner) is walked as PingRunning's own code (a non-component base); T must bind
+        // to Ping, the construction PingRunning : HandlerBase<Ping> actually supplies.
+        var result = await ExtractAsync();
+
+        Assert.Contains(result.Edges, e => e.From == "PingRunning" && e.To == "PingHandling");
+        Assert.DoesNotContain(result.Edges, e => e.From == "PingRunning" && e.To == "PongHandling");
+    }
+
+    [Fact]
+    public async Task An_attribute_on_a_component_is_not_coupling()
+    {
+        // AuditedAttribute's constructor calls AttributeTarget.Touch(); applying [Audited] must not create an edge or
+        // a reach into it.
+        var result = await ExtractAsync();
+        var reaches = result.Components.ToDictionary(c => c.Id, c => c.Reaches ?? []);
+
+        Assert.DoesNotContain(result.Edges, e => e.From == "AttributedRunning" && e.To == "AttributeTarget");
+        Assert.Empty(reaches["AttributedRunning"]);
+    }
+
+    [Fact]
+    public async Task A_collection_initializer_element_runs_the_targets_add_method()
+    {
+        var result = await ExtractAsync();
+
+        Assert.Contains(result.Edges, e => e.From == "CollectionInitializerRunning" && e.To == "AddTarget");
+    }
+
+    [Fact]
+    public async Task A_deconstruction_assignment_runs_deconstruct()
+    {
+        var result = await ExtractAsync();
+
+        Assert.Contains(result.Edges, e => e.From == "DeconstructAssigning" && e.To == "DeconstructTarget");
+    }
+
+    [Fact]
+    public async Task A_foreach_deconstruction_runs_deconstruct()
+    {
+        var result = await ExtractAsync();
+
+        Assert.Contains(result.Edges, e => e.From == "ForeachDeconstructing" && e.To == "DeconstructTarget");
+    }
+
+    [Fact]
+    public async Task A_static_constructor_runs_on_a_static_member_read()
+    {
+        // StaticSeed.Value has no initializer of its own; only the explicit static constructor runs StaticCtorTarget.
+        var result = await ExtractAsync();
+
+        Assert.Contains(result.Edges, e => e.From == "StaticSeedReading" && e.To == "StaticCtorTarget");
+    }
+
+    [Fact]
+    public async Task Await_runs_GetAwaiter_IsCompleted_and_GetResult_on_a_custom_awaitable()
+    {
+        var result = await ExtractAsync();
+
+        Assert.Contains(result.Edges, e => e.From == "Awaiting" && e.To == "GetAwaiterTarget");
+        Assert.Contains(result.Edges, e => e.From == "Awaiting" && e.To == "IsCompletedTarget");
+        Assert.Contains(result.Edges, e => e.From == "Awaiting" && e.To == "GetResultTarget");
+    }
+
+    [Fact]
+    public async Task A_foreach_over_a_hand_written_enumerator_runs_MoveNext_and_Current()
+    {
+        var result = await ExtractAsync();
+
+        Assert.Contains(result.Edges, e => e.From == "CustomForEaching" && e.To == "MoveNextTarget");
+        Assert.Contains(result.Edges, e => e.From == "CustomForEaching" && e.To == "CurrentTarget");
+    }
+
+    [Fact]
+    public async Task A_conditional_access_indexer_runs_the_indexers_getter()
+    {
+        var result = await ExtractAsync();
+
+        Assert.Contains(result.Edges, e => e.From == "ConditionalIndexing" && e.To == "IndexerTarget");
+    }
+
+    [Fact]
+    public async Task Via_lists_the_first_path_found_not_every_raw_edges_via_merged_and_alphabetised()
+    {
+        // GenericMethodDispatching -> PingHandling is reachable only through Dispatch.Send<T>: its via must be that
+        // one discovered path, in the order the walk actually followed it.
+        var result = await ExtractAsync();
+
+        var edge = Assert.Single(result.Edges, e => e.From == "GenericMethodDispatching" && e.To == "PingHandling");
+        Assert.Equal(["IDispatch", "Dispatch", "IHandler", "Decorator", "IHandler"], edge.Via);
+    }
+
+    [Fact]
+    public async Task Via_disambiguates_two_different_types_that_share_a_simple_name()
+    {
+        // CouplingApp.Application.Left.Builder and CouplingApp.Application.Right.Builder are unrelated types that
+        // both happen to be named Builder: via must not show two bare, indistinguishable "Builder" entries.
+        var result = await ExtractAsync();
+
+        var edge = Assert.Single(result.Edges, e => e.From == "ViaDisambiguating" && e.To == "ViaTarget");
+        Assert.Equal(
+            ["CouplingApp.Application.Left.Builder", "CouplingApp.Application.Right.Builder"],
+            edge.Via);
+    }
+
+    [Fact]
+    public async Task An_inherits_edge_for_a_partial_class_cites_the_declaration_that_actually_names_the_base()
+    {
+        // PartialInheriting's first-declared partial fragment lists only IMarker; the second names PartialBase. The
+        // citation must land on the second, not merely the first fragment that has any base list at all.
+        var result = await ExtractAsync();
+
+        var edge = Assert.Single(result.Edges, e => e.From == "PartialInheriting" && e.To == "PartialBase");
+        Assert.Contains("inherits", edge.Kinds);
+        Assert.Equal("src/CouplingApp.Application/PartialInheritCases.Second.cs:11", edge.At);
+    }
+
+    [Fact]
+    public async Task A_non_virtual_member_of_an_abstract_class_is_walked_even_with_no_concrete_subclass()
+    {
+        // PartlyImplemented.Ready has a body and cannot be overridden, so it runs for any (or no) subclass.
+        var result = await ExtractAsync();
+
+        Assert.Contains(result.Edges, e => e.From == "PartlyImplementedUsing" && e.To == "ReadyTarget");
+    }
+
+    [Fact]
+    public async Task An_abstract_member_of_an_abstract_class_with_no_implementation_warns_instead_of_staying_silent()
+    {
+        // PartlyImplemented.Missing is abstract and nothing in the repo derives from PartlyImplemented.
+        var result = await ExtractAsync();
+
+        Assert.Contains("CouplingApp.Application.PartlyImplemented.Missing has no concrete subclass in the repo", result.Warnings);
+    }
+}

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

@@ -0,0 +1,30 @@
+namespace LogicalComponents.Tests;
+
+/// <summary>
+/// Every test class that builds the CouplingApp fixture solution. Kept in its own collection (see
+/// <see cref="FixtureSolutions"/>) so its restore/design-time-build never races the SampleApp fixture's.
+/// </summary>
+[CollectionDefinition(Name)]
+public sealed class CouplingAppFixtureSolutions : ICollectionFixture<CouplingAppWorkspace>
+{
+    public const string Name = "coupling app fixture solutions";
+}
+
+/// <summary>Loads the CouplingApp fixture once and shares it across the classes in its collection.</summary>
+public sealed class CouplingAppWorkspace : IAsyncLifetime
+{
+    // FixturePaths only exposes the fixtures it already knew about; CouplingApp is a sibling directory under the same
+    // fixtures root, owned by this bug-fix batch's own tests.
+    public static string RepoRoot { get; } = Path.Combine(FixturePaths.Root, "CouplingApp");
+
+    public LoadedWorkspace Loaded { get; private set; } = null!;
+
+    public async ValueTask InitializeAsync() => Loaded = await WorkspaceLoader.LoadAsync(RepoRoot);
+
+    public ValueTask DisposeAsync()
+    {
+        // Null when loading failed: disposing must not hide that failure behind a NullReferenceException.
+        Loaded?.Dispose();
+        return ValueTask.CompletedTask;
+    }
+}

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

@@ -38,7 +38,7 @@ public class CouplingExtractionTests(SampleAppWorkspace sample)
                 "Echoing -> PriceFormatting [static] via PingText",
                 "ForwardedNotifier -> Mailer [call,di]",
                 "JobReporting -> CallbackNormalizing [static] via Job",
-                "LabelMaking -> RunClock [call,new] via LabelBase,ShortLabel",
+                "LabelMaking -> RunClock [call,new] via ShortLabel,LabelBase",
                 "Labelling -> RunClock [call] via LabelFormat",
                 "LazyWork -> ForwardedNotifier [di] via INotifier",
                 "LazyWork -> OrderQueue [di] via IOrderQueue",

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

@@ -16,6 +16,10 @@ internal static class FixturePaths
 
     public static string BrokenApp => Path.Combine(Root, "BrokenApp");
 
+    public static string ObjOutputApp => Path.Combine(Root, "ObjOutputApp");
+
+    public static string CompositionRootApp => Path.Combine(Root, "CompositionRootApp");
+
     private static string FindFixturesRoot()
     {
         for (var dir = new DirectoryInfo(AppContext.BaseDirectory); dir is not null; dir = dir.Parent)

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

@@ -33,8 +33,51 @@ public class MarkdownRendererTests
         var markdown = MarkdownRenderer.Render(extraction, responsibilities);
 
         Assert.Contains("    n_end[\"Say #quot;Hi#quot;\"]\n", markdown);
-        Assert.Contains("    n_My_Module_Queue[\"Order Queue\"]\n", markdown);
-        Assert.Contains("    n_end --> n_My_Module_Queue\n", markdown);
+        Assert.Contains("    n_My_x20_Module_x5f_Queue[\"Order Queue\"]\n", markdown);
+        Assert.Contains("    n_end --> n_My_x20_Module_x5f_Queue\n", markdown);
+    }
+
+    [Fact]
+    public void Ids_that_would_collapse_to_the_same_node_under_naive_sanitizing_get_distinct_node_ids()
+    {
+        var extraction = RenderTestData.Extraction with
+        {
+            Components =
+            [
+                RenderTestData.Extraction.Components[0] with { Id = "A B" },
+                RenderTestData.Extraction.Components[2] with { Id = "A-B" },
+            ],
+            ExternalNodes = [],
+            Edges = [new Edge("A B", "A-B", ["di"], [], "src/App/OrderAcceptance.cs:4")],
+        };
+        var responsibilities = RenderTestData.ValidResponsibilities();
+        responsibilities["A B"] = responsibilities["OrderAcceptance"];
+        responsibilities["A-B"] = responsibilities["OrderQueue"];
+
+        var markdown = MarkdownRenderer.Render(extraction, responsibilities);
+
+        Assert.Contains("n_A_x20_B[", markdown);
+        Assert.Contains("n_A_x2d_B[", markdown);
+        Assert.Contains("n_A_x20_B --> n_A_x2d_B", markdown);
+    }
+
+    [Fact]
+    public void Labels_escape_angle_brackets_as_well_as_quotes()
+    {
+        var extraction = RenderTestData.Extraction with
+        {
+            Components = [RenderTestData.Extraction.Components[0] with { Id = "X", Name = "<script>alert(1)</script>" }],
+            ExternalNodes = [],
+            Edges = [],
+        };
+        var responsibilities = RenderTestData.ValidResponsibilities();
+        responsibilities["X"] = responsibilities["OrderAcceptance"];
+
+        var markdown = MarkdownRenderer.Render(extraction, responsibilities);
+
+        // Only the Mermaid label needs escaping: a component's `## Name` heading, unlike a label, is never wrapped
+        // in a way a browser could reinterpret, and Name only ever comes from a C# identifier in practice.
+        Assert.Contains("n_X[\"#lt;script#gt;alert(1)#lt;/script#gt;\"]", markdown);
     }
 
     [Fact]

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

@@ -12,6 +12,8 @@ public class ProjectFiltersTests
     [InlineData("src/Foo.IntegrationTests/Foo.IntegrationTests.csproj")]
     [InlineData("src/Foo.Test/Foo.Test.csproj")]
     [InlineData("src/Foo.Specs/Foo.Specs.csproj")]
+    [InlineData("src/Foo.Spec/Foo.Spec.csproj")]
+    [InlineData("src/Foo.FunctionalTests/Foo.FunctionalTests.csproj")]
     public void Test_folders_and_test_project_names_are_test_projects(string relativePath)
     {
         Assert.True(ProjectFilters.IsTestProject(relativePath, PlainLibrary));
@@ -37,6 +39,8 @@ public class ProjectFiltersTests
     [InlineData("src/Foo.Contest/Foo.Contest.csproj")]
     [InlineData("src/Latest.Feeds/Latest.Feeds.csproj")]
     [InlineData("src/Foo.Testing/Foo.Testing.csproj")]
+    [InlineData("src/Net.SpeedTest/Net.SpeedTest.csproj")]
+    [InlineData("src/Experiments.ABTest/Experiments.ABTest.csproj")]
     public void Source_projects_are_not_test_projects(string relativePath)
     {
         Assert.False(ProjectFilters.IsTestProject(relativePath, PlainLibrary));

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

@@ -108,6 +108,36 @@ public class PruneCommandTests : IDisposable
         Assert.False(Directory.Exists(Pruned));
     }
 
+    [Fact]
+    public async Task A_null_verdict_entry_is_malformed_not_a_crash()
+    {
+        WriteVerdicts("""
+            { "OrderAcceptance": [ null, { "item": 2, "supported": true } ],
+              "OrderQueue": [ { "item": 1, "supported": true } ] }
+            """);
+
+        var (exit, output) = await PruneAsync();
+
+        Assert.Equal(3, exit);
+        Assert.Contains("OrderAcceptance: a null verdict entry (batch-01.json)", output);
+        Assert.False(Directory.Exists(Pruned));
+    }
+
+    [Fact]
+    public async Task A_verdict_missing_supported_is_malformed_not_silently_rejected()
+    {
+        WriteVerdicts("""
+            { "OrderAcceptance": [ { "item": 1 }, { "item": 2, "supported": true } ],
+              "OrderQueue": [ { "item": 1, "supported": true } ] }
+            """);
+
+        var (exit, output) = await PruneAsync();
+
+        Assert.Equal(3, exit);
+        Assert.Contains("OrderAcceptance[1]: verdict is missing 'supported' (batch-01.json)", output);
+        Assert.False(Directory.Exists(Pruned));
+    }
+
     [Fact]
     public async Task A_batch_without_a_verdict_file_fails()
     {