Name the ORM in one place, so Unknown reaches all three renderers

peopleworks#8 taught the core to answer Unknown. The agent files listened; the HTML
explainer and the MCP overview kept deciding in a binary that had no third
answer, so a project whose ORM could not be determined came out as XPO.

The MCP one is the worse of the two. xaf_overview prints the ORM two lines
above "These lists are complete, not sampled", from a tool whose description
tells the agent that anything absent does not exist in the application.

Closes peopleworks#11.

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

Author: peopleworks

CHANGELOG.md

@@ -9,6 +9,14 @@ to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ### Fixed
 
+- **`Unknown` now reaches every place the ORM is reported.** The agent files learned it; the HTML
+  explainer and the MCP `xaf_overview` kept deciding in a binary with no third answer, so a project
+  whose ORM could not be determined was reported as **XPO** by both. The MCP one was the worse of
+  the two: it prints the ORM two lines above "These lists are complete, not sampled", from a tool
+  whose description tells the agent that anything absent does not exist in the application. All
+  three now go through one `Orm` helper — the defect was never the wrong answer, it was that three
+  places were each entitled to one.
+
 - **The ORM is read as syntax, and is `Unknown` when nothing says.** Detection scanned raw file
   text for `DevExpress.Persistent.BaseImpl.EF` and fell through to XPO, so an EF Core application
   whose entities do not use the DevExpress EF base implementation — a legacy schema, its security

README.md

@@ -317,7 +317,7 @@ applications. The agent-facing surface is what is landing now, in the open.
 | ✅ | Pluggable publishing targets (`IDocumentationSink`) |
 | ✅ | **MCP server** — 10 tools, live against your source |
 | ✅ | **Installable Claude Code plugin** with skill and MCP server |
-| ✅ | **282 tests** over synthetic XPO and EF Core fixtures — no DevExpress needed |
+| ✅ | **285 tests** over synthetic XPO and EF Core fixtures — no DevExpress needed |
 | ✅ | **DevExpress ground-truth catalog**, generated locally by licensees |
 
 PeopleWorks Copilot, where this tool grew up, is now one sink among several rather than the

src/XafLogicExplainer.Core/Generators/AgentContextGenerator.cs

@@ -126,7 +126,7 @@ private void WriteHeader(StringBuilder sb, ExtractedProject project)
     private static void WriteSummary(StringBuilder sb, ExtractedProject project)
     {
         var actionCount = project.Controllers.Sum(c => c.Actions.Count);
-        var orm = OrmDisplayName(project.OrmType);
+        var orm = Orm.DisplayName(project.OrmType);
 
         sb.Append($"A DevExpress XAF application: **{project.Entities.Count} business ");
         sb.Append(Plural(project.Entities.Count, "entity", "entities"));
@@ -177,7 +177,7 @@ private static void WriteGroundRules(
             sb.AppendLine();
         }
 
-        var isEfCore = IsEfCore(project.OrmType);
+        var isEfCore = Orm.IsEfCore(project.OrmType);
         var rule = 1;
 
         // Rule 1: the ORM. Mixing XPO and EF Core idioms is the most frequent way generated XAF
@@ -188,7 +188,7 @@ private static void WriteGroundRules(
         // ORM outright, so stating it on a default would forbid whichever one the application
         // actually uses -- worse than silence, because the agent cannot tell a guess from a
         // reading.
-        if (IsOrmUnknown(project.OrmType))
+        if (Orm.IsUnknown(project.OrmType))
         {
             sb.AppendLine($"**{rule++}. The ORM this application uses could not be determined.**");
             sb.AppendLine("No `DbSet<T>` registration, `DbContext`, XPO base class or ORM `using` directive was");
@@ -738,19 +738,6 @@ private static void WriteFooter(StringBuilder sb)
 
     // --------------------------------------------------------------- helpers
 
-    private static bool IsEfCore(string? ormType) =>
-        ormType is not null && ormType.Contains("EF", StringComparison.OrdinalIgnoreCase);
-
-    private static bool IsOrmUnknown(string? ormType) =>
-        ormType is null || ormType.Equals("Unknown", StringComparison.OrdinalIgnoreCase);
-
-    private static string OrmDisplayName(string? ormType) => ormType switch
-    {
-        _ when IsOrmUnknown(ormType) => "an undetermined ORM",
-        _ when IsEfCore(ormType) => "Entity Framework Core",
-        _ => "XPO",
-    };
-
     private static string PropertyMarkers(ExtractedProperty property)
     {
         var markers = new StringBuilder();

src/XafLogicExplainer.Core/Generators/HtmlExplainerGenerator.cs

@@ -91,7 +91,7 @@ private static void WriteHead(StringBuilder sb, ExtractedProject project)
     private static void WriteHeader(StringBuilder sb, ExtractedProject project)
     {
         var actions = project.Controllers.Sum(c => c.Actions.Count);
-        var orm = IsEfCore(project.OrmType) ? "Entity Framework Core" : "XPO";
+        var orm = Orm.Label(project.OrmType);
         var rules = project.Entities.Sum(e => e.ValidationRules.Count + e.AppearanceRules.Count);
 
         sb.AppendLine("<header><div class=\"wrap\">");
@@ -959,8 +959,6 @@ private void WriteFooter(StringBuilder sb, ExtractedProject project)
 
     // --------------------------------------------------------------- helpers
 
-    private static bool IsEfCore(string? orm) =>
-        orm is not null && orm.Contains("EF", StringComparison.OrdinalIgnoreCase);
 
     private static string Describe(RelationshipType type) => type switch
     {

src/XafLogicExplainer.Core/Models/Orm.cs

@@ -0,0 +1,51 @@
+namespace XafLogicExplainer.Core.Models;
+
+/// <summary>
+/// How an application's ORM is named, wherever it is reported.
+/// </summary>
+/// <remarks>
+/// One definition, because there were three. When <see cref="OrmType.Unknown"/> arrived, the agent
+/// files learned it and the HTML explainer and the MCP overview did not — each of those decided the
+/// question again, in a binary that had no third answer, so a project whose ORM the tool could not
+/// determine was reported as XPO. The defect was not the wrong answer; it was that three places
+/// were each entitled to one.
+/// <para>
+/// The ORM travels as a string rather than the enum because <see cref="ExtractedProject.OrmType"/>
+/// is what a rendered snapshot carries and what the MCP server reads back. Comparisons are made
+/// here so that stays an implementation detail nobody downstream copies.
+/// </para>
+/// </remarks>
+public static class Orm
+{
+    /// <summary>The name for a heading or a table cell, where it stands on its own.</summary>
+    public static string Label(string? ormType) =>
+        IsUnknown(ormType) ? "Not determined"
+        : IsEfCore(ormType) ? "Entity Framework Core"
+        : "XPO";
+
+    /// <summary>
+    /// The name for the middle of a sentence, where it needs an article.
+    /// </summary>
+    /// <remarks>
+    /// A second form rather than a second decision: both are written here, so neither can drift
+    /// into disagreeing with the other about what is known. Only the grammar differs.
+    /// </remarks>
+    public static string DisplayName(string? ormType) =>
+        IsUnknown(ormType) ? "an undetermined ORM"
+        : IsEfCore(ormType) ? "Entity Framework Core"
+        : "XPO";
+
+    /// <summary>Whether the source said nothing either way.</summary>
+    /// <remarks>
+    /// A null is unknown too. Anything that never ran detection has not learned XPO.
+    /// </remarks>
+    public static bool IsUnknown(string? ormType) =>
+        string.IsNullOrWhiteSpace(ormType)
+        || ormType.Equals("Unknown", StringComparison.OrdinalIgnoreCase);
+
+    /// <summary>Whether the application persists through Entity Framework Core.</summary>
+    public static bool IsEfCore(string? ormType) =>
+        ormType is not null
+        && !IsUnknown(ormType)
+        && ormType.Contains("EF", StringComparison.OrdinalIgnoreCase);
+}

src/XafLogicExplainer.Mcp/Tools/XafDiscoveryTools.cs

@@ -37,9 +37,7 @@ public async Task<string> OverviewAsync(
         var sb = new StringBuilder();
 
         var actionCount = app.Controllers.Sum(c => c.Actions.Count);
-        var orm = app.OrmType.Contains("EF", StringComparison.OrdinalIgnoreCase)
-            ? "Entity Framework Core"
-            : "XPO";
+        var orm = Orm.Label(app.OrmType);
 
         sb.AppendLine($"# {app.ProjectName}");
         sb.AppendLine();

tests/XafLogicExplainer.Tests/OverReportingTests.cs

@@ -2,7 +2,10 @@
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using XafLogicExplainer.Core.Analyzers;
 using XafLogicExplainer.Core.Catalog;
+using XafLogicExplainer.Core.Generators;
 using XafLogicExplainer.Core.Models;
+using XafLogicExplainer.Mcp;
+using XafLogicExplainer.Mcp.Tools;
 
 namespace XafLogicExplainer.Tests;
 
@@ -246,6 +249,44 @@ public void DoesNotRegisterADbSetWrittenAsALocal()
         Assert.DoesNotContain("AuditEntry", names);
     }
 
+    [Fact]
+    public void DoesNotNameAnOrmTheSourceNeverNamed()
+    {
+        // Three renderers each decided this separately, in a binary with no third answer, so a
+        // project whose ORM could not be determined was reported as XPO by two of them. The defect
+        // was not the wrong answer -- it was that three places were each entitled to one.
+        Assert.Equal("Not determined", Orm.Label("Unknown"));
+        Assert.Equal("an undetermined ORM", Orm.DisplayName("Unknown"));
+
+        // A null has not learned XPO either. Anything that never ran detection is unknown.
+        Assert.True(Orm.IsUnknown(null));
+        Assert.False(Orm.IsEfCore("Unknown"));
+    }
+
+    [Fact]
+    public void TheHtmlExplainerDoesNotClaimXpoForAnUndeterminedProject()
+    {
+        var page = new HtmlExplainerGenerator("0.0.0").Generate(SampleProjects.NoOrm);
+
+        Assert.DoesNotContain("<strong>XPO</strong>", page);
+        Assert.Contains("Not determined", page);
+    }
+
+    [Fact]
+    public async Task TheMcpOverviewDoesNotClaimXpoForAnUndeterminedProject()
+    {
+        // The surface that speaks with the most authority: `xaf_overview` prints the ORM two lines
+        // above "These lists are complete, not sampled", from a tool whose description tells the
+        // agent that anything absent does not exist in the application.
+        var tools = new XafDiscoveryTools(new XafProjectContext(
+            [new XafProjectSource { Name = "SampleNoOrm", Path = SampleProjects.NoOrmPath, Language = "en" }]));
+
+        var overview = await tools.OverviewAsync(cancellationToken: TestContext.Current.CancellationToken);
+
+        Assert.DoesNotContain("**XPO**", overview);
+        Assert.Contains("Not determined", overview);
+    }
+
     private static ControllerTargeting Read(string source) =>
         ControllerTargetingReader.Read(CSharpSyntaxTree.ParseText(source).GetRoot()
             .DescendantNodes().OfType<ClassDeclarationSyntax>().First());