Recognise PersistentBase and XPBaseObject as persistent bases

The XPO hierarchy is PersistentBase -> XPBaseObject -> XPCustomObject ->
XPObject, with XPLiteObject also under XPBaseObject. BaseTypeNames held the
three leaves and neither of the classes above them, so the hole sat in the
middle of an API that is used rather than at its edge: DevExpress documents all
five as bases a persistent class may derive from, and recommends PersistentBase.

Deriving from the higher bases is what you do when the table already brings its
own key -- the same population of legacy schemas the DbSet roster was added for,
which is why this turned up beside it.

FeatureCenter.NET.XPO gains OidGenerator, NoKeyPropertyNamedBaseObject and
LayoutDemoObject, all of them ": XPBaseObject". Nothing changes for MainDemo in
either ORM, for OutlookInspired, or for a private 221-entity EF Core
application. No demo derives from PersistentBase directly, so that half is
covered by the fixture rather than by a corpus.

The list also stops being duplicated. The CLI, the MCP server and the test
harness each passed their own copy, so the default in Core was four names while
every caller passed five -- four copies and three chances for them to disagree
about what an entity is. They now use the default.

Fixes peopleworks#6 in part; the transitive walk in peopleworks#9 is the rest.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: 2 people

CHANGELOG.md

@@ -7,6 +7,13 @@ to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ## [Unreleased]
 
+### Changed
+
+- **`ExtractionOptions.BaseTypeNames` is the single source of the list.** The CLI, the MCP server
+  and the test harness each passed their own copy, so the default in `Core` was four names while
+  every caller passed five — four copies with three chances to disagree about what an entity is.
+  The callers now use the default.
+
 ### Fixed
 
 - **`Unknown` now reaches every place the ORM is reported.** The agent files learned it; the HTML
@@ -28,6 +35,15 @@ to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
   omitted rather than guessed. Reading text also counted a *mention*: a comment naming the
   namespace was enough, which is how the fixture for this fix first passed against the old code.
 
+- **`PersistentBase` and `XPBaseObject` are recognised as persistent bases.** The XPO hierarchy is
+  `PersistentBase` → `XPBaseObject` → `XPCustomObject` → `XPObject`, with `XPLiteObject` also under
+  `XPBaseObject`. The list held the three leaves and neither of the classes above them, so a hole
+  sat in the middle of a documented API — DevExpress names all five as bases a persistent class may
+  derive from, and recommends `PersistentBase`. Deriving from the higher bases is what you do when
+  the table brings its own key, which is the same population as the legacy schemas the DbSet roster
+  was added for. `FeatureCenter.NET.XPO` gains `OidGenerator`, `NoKeyPropertyNamedBaseObject` and
+  `LayoutDemoObject`.
+
 ## [0.12.1] — 2026-08-13
 
 Entities the application declares, rather than the ones that inherit from the right class.

src/XafLogicExplainer.Cli/Program.cs

@@ -1838,7 +1838,6 @@ static ExtractionOptions BuildExtractionOptions(string language, string? orm = n
 {
     var options = new ExtractionOptions
     {
-        BaseTypeNames = ["XPCustomObject", "BaseObject", "XPObject", "XPLiteObject", "PermissionPolicyUser"],
         IncludeSourceCode = true,
         IncludeMethodBodies = true,
         IncludeComments = true,

src/XafLogicExplainer.Core/Models/ExtractionOptions.cs

@@ -64,11 +64,28 @@ public class ExtractionOptions
     /// <summary>
     /// Known business object base types used to classify entity classes.
     /// </summary>
+    /// <remarks>
+    /// The XPO names are the whole documented hierarchy —
+    /// <c>PersistentBase</c> → <c>XPBaseObject</c> → <c>XPCustomObject</c> → <c>XPObject</c>, with
+    /// <c>XPLiteObject</c> also under <c>XPBaseObject</c> — because DevExpress names all five as
+    /// bases a persistent class may derive from, and recommends <c>PersistentBase</c>. Listing the
+    /// leaves and not the two classes above them leaves a hole in the middle of an API that is
+    /// used: mapping onto a table that brings its own key is exactly when the higher bases are the
+    /// right choice.
+    /// <para>
+    /// Callers are expected to use this list rather than pass their own. It was previously
+    /// duplicated in the CLI, the MCP server and the test harness, which is three chances for the
+    /// four copies to disagree about what an entity is.
+    /// </para>
+    /// </remarks>
     public string[] BaseTypeNames { get; set; } = [
+        "PersistentBase",
+        "XPBaseObject",
         "XPCustomObject",
-        "BaseObject",
         "XPObject",
-        "XPLiteObject"
+        "XPLiteObject",
+        "BaseObject",
+        "PermissionPolicyUser",
     ];
 
     /// <summary>

src/XafLogicExplainer.Mcp/XafProjectContext.cs

@@ -159,7 +159,6 @@ private static ExtractionOptions BuildOptions(XafProjectSource source)
     {
         var options = new ExtractionOptions
         {
-            BaseTypeNames = ["XPCustomObject", "BaseObject", "XPObject", "XPLiteObject", "PermissionPolicyUser"],
             IncludeSourceCode = true,
             IncludeMethodBodies = true,
             IncludeComments = true,

tests/XafLogicExplainer.Tests/ExtractionTests.cs

@@ -12,7 +12,7 @@ public void FindsEveryEntity()
     {
         var names = SampleProjects.Xpo.Entities.Select(e => e.ClassName).OrderBy(n => n).ToList();
 
-        Assert.Equal(["Customer", "Order", "OrderLine"], names);
+        Assert.Equal(["AuditEntry", "Customer", "Order", "OrderLine", "SequenceCounter"], names);
     }
 
     [Fact]

tests/XafLogicExplainer.Tests/Fixtures/XpoSolution/SampleApp.Module/BusinessObjects/AuditEntry.cs

@@ -0,0 +1,30 @@
+using System;
+using System.ComponentModel;
+using DevExpress.Persistent.Base;
+using DevExpress.Xpo;
+
+namespace SampleApp.Module.BusinessObjects;
+
+/// <summary>
+/// A row written when something changes. Derived from <c>XPBaseObject</c>, which carries no key
+/// of its own, so the class supplies one.
+/// </summary>
+/// <remarks>
+/// <c>XPBaseObject</c> is the ancestor of <c>XPCustomObject</c> and a documented base for
+/// persistent classes in its own right — mapping onto a table that already has its own key is
+/// exactly when it is the right choice.
+/// </remarks>
+[DefaultClassOptions]
+[NavigationItem("Audit")]
+public class AuditEntry : XPBaseObject
+{
+    public AuditEntry(Session session) : base(session) { }
+
+    [Key(AutoGenerate = true), Browsable(false)]
+    public int Oid { get; set; }
+
+    [Size(80)]
+    public string ChangedBy { get; set; }
+
+    public DateTime ChangedOn { get; set; }
+}

tests/XafLogicExplainer.Tests/Fixtures/XpoSolution/SampleApp.Module/BusinessObjects/SequenceCounter.cs

@@ -0,0 +1,20 @@
+using System.ComponentModel;
+using DevExpress.Persistent.Base;
+using DevExpress.Xpo;
+
+namespace SampleApp.Module.BusinessObjects;
+
+/// <summary>
+/// The next number to hand out for a document type. Derived from <c>PersistentBase</c>, the root
+/// of the XPO hierarchy and the class DevExpress recommends as a base for persistent classes.
+/// </summary>
+[DefaultClassOptions]
+public class SequenceCounter : PersistentBase
+{
+    public SequenceCounter(Session session) : base(session) { }
+
+    [Key, Size(60)]
+    public string TypeName { get; set; }
+
+    public long NextNumber { get; set; }
+}

tests/XafLogicExplainer.Tests/HtmlExplainerTests.cs

@@ -123,7 +123,7 @@ public void GraphPlacesEveryEntity()
     {
         var graph = EntityGraph.Build(SampleProjects.Xpo);
 
-        Assert.Equal(3, graph.Nodes.Count);
+        Assert.Equal(5, graph.Nodes.Count);
         Assert.All(graph.Nodes, n => Assert.InRange(n.X, 0, graph.Width));
         Assert.All(graph.Nodes, n => Assert.InRange(n.Y, 0, graph.Height));
     }

tests/XafLogicExplainer.Tests/McpToolTests.cs

@@ -105,7 +105,7 @@ public async Task AbsentEntityReturnsTheCompleteInventoryAndSaysItDoesNotExist()
         var result = await Detail.EntityAsync("PurchaseOrder", cancellationToken: TestContext.Current.CancellationToken);
 
         Assert.Contains("There is no entity called 'PurchaseOrder'", result);
-        Assert.Contains("complete list of 3 entities", result);
+        Assert.Contains("complete list of 5 entities", result);
         Assert.Contains("Customer", result);
         Assert.Contains("has not been created yet", result);
     }

tests/XafLogicExplainer.Tests/OrmDetectionTests.cs

@@ -14,6 +14,19 @@ public class OrmDetectionTests
     public void DetectsXpo() =>
         Assert.Equal("XPO", SampleProjects.Xpo.OrmType, ignoreCase: true);
 
+    [Fact]
+    public void FindsEntitiesOnEveryDocumentedXpoBase()
+    {
+        // The hierarchy is PersistentBase -> XPBaseObject -> XPCustomObject -> XPObject, with
+        // XPLiteObject also under XPBaseObject. Recognising the leaves and not the two classes
+        // above them leaves a hole in the middle of a documented API: DevExpress names all five
+        // as bases you may derive persistent classes from, and recommends PersistentBase.
+        var names = SampleProjects.Xpo.Entities.Select(entity => entity.ClassName);
+
+        Assert.Contains("AuditEntry", names);       // : XPBaseObject
+        Assert.Contains("SequenceCounter", names);  // : PersistentBase
+    }
+
     [Fact]
     public void DetectsEfCoreFromItsNamespace() =>
         Assert.Contains("EF", SampleProjects.EfCore.OrmType, StringComparison.OrdinalIgnoreCase);