d365fo-mcp 1.13.0 → 1.14.0

package/bridge/D365MetadataBridge/Program.cs

@@ -1,9 +1,11 @@
 using System;
+using System.Collections.Generic;
 using System.Diagnostics;
 using System.IO;
 using System.Reflection;
 using System.Runtime.CompilerServices;
 using System.Text.Json;
+using System.Threading;
 using System.Threading.Tasks;
 using D365MetadataBridge.Protocol;
 
@@ -219,9 +221,33 @@ namespace D365MetadataBridge
             }
         }
 
+        /// <summary>
+        /// How many reads may be inside the provider at once. Bounded on purpose: the
+        /// win is in overlapping a handful of fan-out reads, not in handing an unbounded
+        /// number of threads to a metadata provider whose thread-safety is undocumented.
+        /// </summary>
+        private const int ReadSlots = 6;
+
+        /// <summary>
+        /// A read takes one slot; anything else takes ALL of them, which is what makes a
+        /// write or a provider refresh exclusive against every in-flight read. Simple
+        /// enough to reason about without an async reader/writer lock.
+        ///
+        /// A writer waits for the slots, so a continuous stream of reads could delay it.
+        /// In practice requests come from one MCP client that awaits its own calls, so
+        /// there is no such stream.
+        /// </summary>
+        private static readonly SemaphoreSlim _slots = new SemaphoreSlim(ReadSlots, ReadSlots);
+
+        /// <summary>stdout is one stream: concurrent handlers must not interleave lines on it.</summary>
+        private static readonly SemaphoreSlim _stdoutLock = new SemaphoreSlim(1, 1);
+        private static readonly StreamWriter _stdout =
+            new StreamWriter(Console.OpenStandardOutput()) { AutoFlush = true };
+
         private static async Task<int> RunStdioLoop(RequestDispatcher dispatcher)
         {
             var reader = new StreamReader(Console.OpenStandardInput());
+            var inFlight = new List<Task>();
 
             string? line;
             while ((line = await reader.ReadLineAsync()) != null)
@@ -229,45 +255,127 @@ namespace D365MetadataBridge
                 if (string.IsNullOrWhiteSpace(line))
                     continue;
 
-                BridgeResponse response;
+                BridgeRequest? request = null;
                 try
                 {
-                    var request = JsonSerializer.Deserialize<BridgeRequest>(line, JsonOptions.Default);
-                    if (request == null || string.IsNullOrEmpty(request.Method))
-                    {
-                        response = BridgeResponse.CreateError("?", -32600, "Invalid request");
-                    }
-                    else
-                    {
-                        Log.WriteLine($"[DEBUG] → {request.Method} (id={request.Id})");
-                        response = await dispatcher.Dispatch(request);
-                        Log.WriteLine($"[DEBUG] ← {request.Method} OK (id={request.Id})");
-                    }
+                    request = JsonSerializer.Deserialize<BridgeRequest>(line, JsonOptions.Default);
                 }
                 catch (JsonException ex)
                 {
                     Log.WriteLine($"[ERROR] JSON parse error: {ex.Message}");
-                    response = BridgeResponse.CreateError("?", -32700, $"Parse error: {ex.Message}");
+                    await WriteResponse(BridgeResponse.CreateError("?", -32700, $"Parse error: {ex.Message}"));
+                    continue;
                 }
-                catch (Exception ex)
+
+                if (request == null || string.IsNullOrEmpty(request.Method))
                 {
-                    Log.WriteLine($"[ERROR] Unhandled: {ex.Message}\n{ex.StackTrace}");
-                    response = BridgeResponse.CreateError("?", -32603, $"Internal error: {ex.Message}");
+                    await WriteResponse(BridgeResponse.CreateError("?", -32600, "Invalid request"));
+                    continue;
                 }
 
-                await WriteResponse(response);
+                // Reads go to the thread pool so the loop can read the next line at once;
+                // everything else keeps the original behaviour of running to completion
+                // before the next request is even parsed.
+                if (RequestDispatcher.IsConcurrentSafeRead(request.Method))
+                {
+                    // Touch Exception on a faulted task before dropping it, so the fault
+                    // is observed rather than left for the finalizer — a task pruned here
+                    // is never awaited anywhere else.
+                    inFlight.RemoveAll(t =>
+                    {
+                        if (t.IsFaulted) { var _ = t.Exception; }
+                        return t.IsCompleted;
+                    });
+                    inFlight.Add(HandleConcurrently(dispatcher, request));
+                }
+                else
+                {
+                    // Drain the reads already running, then take every slot: a write or a
+                    // provider rebuild must not overlap a read of the provider it replaces.
+                    if (inFlight.Count > 0)
+                    {
+                        // Guarded. DispatchGuarded turns any handler escape into a
+                        // response, so the only realistic thrower left is WriteResponse on
+                        // a broken stdout — and an unguarded WhenAll rethrows that HERE,
+                        // out of RunStdioLoop and out of Main, killing the bridge because
+                        // an unrelated read could not print. The final drain below was
+                        // already written this way; this one was not.
+                        try { await Task.WhenAll(inFlight); }
+                        catch { /* each read already answered, or failed on its own */ }
+                        inFlight.Clear();
+                    }
+                    for (var i = 0; i < ReadSlots; i++) await _slots.WaitAsync();
+                    try
+                    {
+                        await WriteResponse(await DispatchGuarded(dispatcher, request));
+                    }
+                    finally
+                    {
+                        _slots.Release(ReadSlots);
+                    }
+                }
             }
 
+            if (inFlight.Count > 0)
+            {
+                try { await Task.WhenAll(inFlight); } catch { /* each response was already sent */ }
+            }
             Log.WriteLine("[INFO] stdin closed, bridge exiting");
             return 0;
         }
 
+        /// <summary>One read: take a slot, dispatch, answer. Never throws back into the loop.</summary>
+        private static async Task HandleConcurrently(RequestDispatcher dispatcher, BridgeRequest request)
+        {
+            await _slots.WaitAsync();
+            try
+            {
+                // Task.Run, not a bare await: every read handler returns
+                // Task.FromResult(...), so Dispatch runs to completion SYNCHRONOUSLY on
+                // whichever thread calls it. Awaiting it here left the work on the stdio
+                // loop thread and measured 1.06x against 1.04x for the serial build —
+                // the change did nothing until the work actually left this thread.
+                var response = await Task.Run(() => DispatchGuarded(dispatcher, request));
+                await WriteResponse(response);
+            }
+            finally
+            {
+                _slots.Release();
+            }
+        }
+
+        /// <summary>Dispatch, turning any escape into a response rather than a lost request.</summary>
+        private static async Task<BridgeResponse> DispatchGuarded(RequestDispatcher dispatcher, BridgeRequest request)
+        {
+            try
+            {
+                Log.WriteLine($"[DEBUG] → {request.Method} (id={request.Id})");
+                var response = await dispatcher.Dispatch(request);
+                Log.WriteLine($"[DEBUG] ← {request.Method} OK (id={request.Id})");
+                return response;
+            }
+            catch (Exception ex)
+            {
+                Log.WriteLine($"[ERROR] Unhandled: {ex.Message}\n{ex.StackTrace}");
+                return BridgeResponse.CreateError(request.Id, -32603, $"Internal error: {ex.Message}");
+            }
+        }
+
         private static async Task WriteResponse(BridgeResponse response)
         {
             var json = JsonSerializer.Serialize(response, JsonOptions.Default);
-            var stdout = new StreamWriter(Console.OpenStandardOutput()) { AutoFlush = true };
-            await stdout.WriteLineAsync(json);
-            await stdout.FlushAsync();
+            // Serialized, and on ONE cached writer: concurrent handlers each opening their
+            // own StreamWriter over the same handle is how a JSON-RPC stream gets interleaved.
+            await _stdoutLock.WaitAsync();
+            try
+            {
+                await _stdout.WriteLineAsync(json);
+                await _stdout.FlushAsync();
+            }
+            finally
+            {
+                _stdoutLock.Release();
+            }
         }
 
         /// <summary>

package/bridge/D365MetadataBridge/Protocol/RequestDispatcher.cs

@@ -813,6 +813,43 @@ namespace D365MetadataBridge.Protocol
             }
         }
 
+        /// <summary>
+        /// Methods that only READ metadata, and may therefore run concurrently with
+        /// each other.
+        ///
+        /// Measured on this VM: six reads issued together took 674 ms against 689 ms
+        /// issued one at a time — a 1.02x "speedup", because the stdio loop awaited each
+        /// Dispatch before reading the next line. Every fan-out the TS side performs
+        /// (get_object_info objects[], search queries[], prepare's five probes) was
+        /// therefore pipelining into a queue of one.
+        ///
+        /// The list is explicit and the DEFAULT IS FALSE: anything not named here —
+        /// including a method added later — keeps the old exclusive behaviour. A write
+        /// misfiled as a read would corrupt metadata; a read misfiled as a write is
+        /// merely as slow as it is today.
+        /// </summary>
+        private static readonly HashSet<string> ConcurrentSafeReads =
+            new HashSet<string>(StringComparer.OrdinalIgnoreCase)
+            {
+                "ping", "getcapabilities", "getinfo", "getxrefschema",
+                // Typed readers
+                "readtable", "readclass", "readenum", "readedt", "readform", "readquery",
+                "readview", "readreport", "readdataentity", "readmenuitem",
+                "readsecurityprivilege", "readsecurityduty", "readsecurityrole",
+                "readtableextensions",
+                // Short aliases of the same readers
+                "table", "class", "enum", "edt", "form", "query", "view", "menu",
+                // Lookup / search
+                "searchobjects", "listobjects", "resolveobjectinfo", "getcompletionmembers",
+                "getmethodsource", "validateobject", "discoverformpatterns",
+                // Cross-reference queries
+                "findreferences", "findeventsubscribers", "findextensionclasses",
+                "findapiusagecallers", "samplexrefrows",
+            };
+
+        /// <summary>True when <paramref name="method"/> may run alongside other reads.</summary>
+        public static bool IsConcurrentSafeRead(string? method)
+            => !string.IsNullOrEmpty(method) && ConcurrentSafeReads.Contains(method!);
         private Task<BridgeResponse> HandleMetadata(BridgeRequest request, Func<object?> handler)
         {
             if (_metadataService == null)

package/bridge/D365MetadataBridge/Services/MetadataReadService.cs

@@ -1150,68 +1150,65 @@ namespace D365MetadataBridge.Services
             // seen set prevents duplicate names when the same object exists in both providers
             var seen = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
 
-            void Search(string objType, IList<string> keys)
+            // Takes the getter, not a materialized list: as an ARGUMENT, Keys(...) ran to
+            // completion before this method could return, so every collection was fully
+            // enumerated even when the result budget was already full. For the default
+            // "all" filter that is 14 primary-key lists per search, on both providers.
+            void Search(string objType, Func<IEnumerable<string>> getter)
             {
-                if (keys == null) return;
-                foreach (var n in keys)
+                // Budget spent — do not touch this collection at all.
+                if (result.Results.Count >= maxResults) return;
+                try
                 {
-                    if (result.Results.Count >= maxResults) return;
-                    if (n.IndexOf(query, StringComparison.OrdinalIgnoreCase) >= 0 && seen.Add(n))
-                        result.Results.Add(new SearchItemModel { Name = n, Type = objType });
+                    var raw = getter();
+                    if (raw == null) return;
+                    foreach (var n in raw)
+                    {
+                        // Stops ENUMERATING, not merely adding.
+                        if (result.Results.Count >= maxResults) return;
+                        if (n.IndexOf(query, StringComparison.OrdinalIgnoreCase) >= 0 && seen.Add(n))
+                            result.Results.Add(new SearchItemModel { Name = n, Type = objType });
+                    }
+                }
+                catch (Exception ex)
+                {
+                    Console.Error.WriteLine($"[WARN] Search: could not list '{objType}': {ex.GetType().Name}: {ex.Message}");
                 }
             }
 
-            // Materialize primary keys from a provider collection.
-            // IMPORTANT: these are accessed STRONGLY-TYPED through the public
+            // Collections are accessed STRONGLY-TYPED through the public
             // Microsoft.Dynamics.AX.Metadata.Providers.IMetadataProvider interface — NOT via
             // `dynamic`. The concrete provider (DiskMetadataProvider) is an internal type, and
             // the DLR cannot bind to public members of an internal type from this assembly:
             // `dynamic dyn = prov; dyn.MenuItemDisplays` throws RuntimeBinderException
             // ("'object' does not contain a definition for 'MenuItemDisplays'") and silently
             // yields nothing — which is exactly how menu items/security stayed invisible.
-            // Interface access binds at compile time and works. Keys are enumerated (not cast
-            // to IList<string>) so a lazy IEnumerable<string> return is handled safely too.
-            List<string> Keys(string label, Func<IEnumerable<string>> getter)
-            {
-                var list = new List<string>();
-                try
-                {
-                    var raw = getter();
-                    if (raw != null)
-                        foreach (var k in raw) list.Add(k);
-                }
-                catch (Exception ex)
-                {
-                    Console.Error.WriteLine($"[WARN] Search: could not list '{label}': {ex.GetType().Name}: {ex.Message}");
-                }
-                return list;
-            }
-
+            // Interface access binds at compile time and works.
             void SearchProvider(IMetadataProvider prov)
             {
                 try
                 {
                     switch (type.ToLowerInvariant())
                     {
-                        case "table": Search("table", Keys("table", () => prov.Tables.GetPrimaryKeys())); break;
-                        case "class": Search("class", Keys("class", () => prov.Classes.GetPrimaryKeys())); break;
-                        case "enum": Search("enum", Keys("enum", () => prov.Enums.GetPrimaryKeys())); break;
-                        case "edt": Search("edt", Keys("edt", () => prov.Edts.GetPrimaryKeys())); break;
-                        case "form": Search("form", Keys("form", () => prov.Forms.GetPrimaryKeys())); break;
-                        case "query": Search("query", Keys("query", () => prov.Queries.GetPrimaryKeys())); break;
-                        case "view": Search("view", Keys("view", () => prov.Views.GetPrimaryKeys())); break;
+                        case "table": Search("table", () => prov.Tables.GetPrimaryKeys()); break;
+                        case "class": Search("class", () => prov.Classes.GetPrimaryKeys()); break;
+                        case "enum": Search("enum", () => prov.Enums.GetPrimaryKeys()); break;
+                        case "edt": Search("edt", () => prov.Edts.GetPrimaryKeys()); break;
+                        case "form": Search("form", () => prov.Forms.GetPrimaryKeys()); break;
+                        case "query": Search("query", () => prov.Queries.GetPrimaryKeys()); break;
+                        case "view": Search("view", () => prov.Views.GetPrimaryKeys()); break;
                         case "data-entity":
-                        case "dataentity": Search("data-entity", Keys("data-entity", () => prov.DataEntityViews.GetPrimaryKeys())); break;
+                        case "dataentity": Search("data-entity", () => prov.DataEntityViews.GetPrimaryKeys()); break;
 
-                        case "menu-item-display": Search("menu-item-display", Keys("menu-item-display", () => prov.MenuItemDisplays.GetPrimaryKeys())); break;
-                        case "menu-item-action": Search("menu-item-action", Keys("menu-item-action", () => prov.MenuItemActions.GetPrimaryKeys())); break;
-                        case "menu-item-output": Search("menu-item-output", Keys("menu-item-output", () => prov.MenuItemOutputs.GetPrimaryKeys())); break;
+                        case "menu-item-display": Search("menu-item-display", () => prov.MenuItemDisplays.GetPrimaryKeys()); break;
+                        case "menu-item-action": Search("menu-item-action", () => prov.MenuItemActions.GetPrimaryKeys()); break;
+                        case "menu-item-output": Search("menu-item-output", () => prov.MenuItemOutputs.GetPrimaryKeys()); break;
 
-                        case "security-privilege": Search("security-privilege", Keys("security-privilege", () => prov.SecurityPrivileges.GetPrimaryKeys())); break;
-                        case "security-duty": Search("security-duty", Keys("security-duty", () => prov.SecurityDuties.GetPrimaryKeys())); break;
-                        case "security-role": Search("security-role", Keys("security-role", () => prov.SecurityRoles.GetPrimaryKeys())); break;
+                        case "security-privilege": Search("security-privilege", () => prov.SecurityPrivileges.GetPrimaryKeys()); break;
+                        case "security-duty": Search("security-duty", () => prov.SecurityDuties.GetPrimaryKeys()); break;
+                        case "security-role": Search("security-role", () => prov.SecurityRoles.GetPrimaryKeys()); break;
 
-                        case "table-extension": Search("table-extension", Keys("table-extension", () => prov.TableExtensions.GetPrimaryKeys())); break;
+                        case "table-extension": Search("table-extension", () => prov.TableExtensions.GetPrimaryKeys()); break;
                         // IMetadataProvider has no ClassExtensions collection — CoC/augmentation
                         // classes live in the regular Classes collection (named *_Extension). The
                         // bridge can't filter them out here, so return nothing and let the caller
@@ -1219,28 +1216,28 @@ namespace D365MetadataBridge.Services
                         case "class-extension":
                             Console.Error.WriteLine("[DEBUG] Search: class-extension requested — no IMetadataProvider collection; falling back to SQLite index");
                             break;
-                        case "form-extension": Search("form-extension", Keys("form-extension", () => prov.FormExtensions.GetPrimaryKeys())); break;
-                        case "enum-extension": Search("enum-extension", Keys("enum-extension", () => prov.EnumExtensions.GetPrimaryKeys())); break;
-                        case "edt-extension": Search("edt-extension", Keys("edt-extension", () => prov.EdtExtensions.GetPrimaryKeys())); break;
-                        case "data-entity-extension": Search("data-entity-extension", Keys("data-entity-extension", () => prov.DataEntityViewExtensions.GetPrimaryKeys())); break;
+                        case "form-extension": Search("form-extension", () => prov.FormExtensions.GetPrimaryKeys()); break;
+                        case "enum-extension": Search("enum-extension", () => prov.EnumExtensions.GetPrimaryKeys()); break;
+                        case "edt-extension": Search("edt-extension", () => prov.EdtExtensions.GetPrimaryKeys()); break;
+                        case "data-entity-extension": Search("data-entity-extension", () => prov.DataEntityViewExtensions.GetPrimaryKeys()); break;
 
                         default:
                             // "all" (or any unrecognized filter): enumerate every object kind so
                             // nothing — menu items included — is silently invisible to search.
-                            Search("table", Keys("table", () => prov.Tables.GetPrimaryKeys()));
-                            Search("class", Keys("class", () => prov.Classes.GetPrimaryKeys()));
-                            Search("enum", Keys("enum", () => prov.Enums.GetPrimaryKeys()));
-                            Search("edt", Keys("edt", () => prov.Edts.GetPrimaryKeys()));
-                            Search("form", Keys("form", () => prov.Forms.GetPrimaryKeys()));
-                            Search("query", Keys("query", () => prov.Queries.GetPrimaryKeys()));
-                            Search("view", Keys("view", () => prov.Views.GetPrimaryKeys()));
-                            Search("data-entity", Keys("data-entity", () => prov.DataEntityViews.GetPrimaryKeys()));
-                            Search("menu-item-display", Keys("menu-item-display", () => prov.MenuItemDisplays.GetPrimaryKeys()));
-                            Search("menu-item-action", Keys("menu-item-action", () => prov.MenuItemActions.GetPrimaryKeys()));
-                            Search("menu-item-output", Keys("menu-item-output", () => prov.MenuItemOutputs.GetPrimaryKeys()));
-                            Search("security-privilege", Keys("security-privilege", () => prov.SecurityPrivileges.GetPrimaryKeys()));
-                            Search("security-duty", Keys("security-duty", () => prov.SecurityDuties.GetPrimaryKeys()));
-                            Search("security-role", Keys("security-role", () => prov.SecurityRoles.GetPrimaryKeys()));
+                            Search("table", () => prov.Tables.GetPrimaryKeys());
+                            Search("class", () => prov.Classes.GetPrimaryKeys());
+                            Search("enum", () => prov.Enums.GetPrimaryKeys());
+                            Search("edt", () => prov.Edts.GetPrimaryKeys());
+                            Search("form", () => prov.Forms.GetPrimaryKeys());
+                            Search("query", () => prov.Queries.GetPrimaryKeys());
+                            Search("view", () => prov.Views.GetPrimaryKeys());
+                            Search("data-entity", () => prov.DataEntityViews.GetPrimaryKeys());
+                            Search("menu-item-display", () => prov.MenuItemDisplays.GetPrimaryKeys());
+                            Search("menu-item-action", () => prov.MenuItemActions.GetPrimaryKeys());
+                            Search("menu-item-output", () => prov.MenuItemOutputs.GetPrimaryKeys());
+                            Search("security-privilege", () => prov.SecurityPrivileges.GetPrimaryKeys());
+                            Search("security-duty", () => prov.SecurityDuties.GetPrimaryKeys());
+                            Search("security-role", () => prov.SecurityRoles.GetPrimaryKeys());
                             break;
                     }
                 }

package/dist/bridge/bridgeAdapter.js

@@ -1144,7 +1144,12 @@ const BRIDGE_MODIFY_OPS = new Set([
     // (MetadataWriteService exposes no RemoveControl, and security objects have no
     // bridge write path at all) — both are served by a direct-XML writer and still
     // pass through this gate.
-    'remove-control', 'remove-entry-point',
+    // add-entry-point shipped its schema entry, op-spec, dispatcher case and writer
+    // without ever being listed here, so canBridgeModify() short-circuited and the
+    // whole feature was unreachable from the tool surface — dead code behind a ✅
+    // schema. Both this set AND XML_ONLY_MODIFY_PAIRS have to name it; either alone
+    // still returns false. (eval case L2-object-delete-and-entry-point-cleanup)
+    'remove-control', 'add-entry-point', 'remove-entry-point',
     // AxIgnoreDiagnosticList is not an AOT object at all — MetadataWriteService has
     // no concept of it — so this is XML-only for the same structural reason as the
     // two above.
@@ -1183,6 +1188,7 @@ const BRIDGE_MODIFY_TYPES = new Set([
  * a bridge resolution failure instead of "not supported for this object type".
  */
 const XML_ONLY_MODIFY_PAIRS = {
+    'add-entry-point': new Set(['security-privilege']),
     'remove-entry-point': new Set(['security-privilege']),
     'remove-diagnostic-suppression': new Set(['ignore-diagnostic-list']),
     'add-diagnostic-suppression': new Set(['ignore-diagnostic-list']),

package/dist/cli/session/analyze.js

@@ -26,7 +26,12 @@ const MAX_RELATIVE_RMSE = 0.02;
  * covers the tool's primary use — `labels` has a bulk create but its searches
  * (the common case) have no batch form, and flagging those would be noise.
  */
-const PLURAL_FORM_TOOLS = ['get_object_info', 'run_bp_check', 'verify_d365fo_project'];
+const PLURAL_FORM_TOOLS = [
+    'get_object_info', 'run_bp_check', 'verify_d365fo_project',
+    'd365fo_file', // operations[] applies many edits to one object in a call
+    'get_knowledge', // topics[] answers several lookups in a call
+    'search', // queries[] runs several searches in one call, in parallel
+];
 /**
  * Least squares with no intercept, three unknowns, via the normal equations.
  *

package/dist/knowledge/kernelEnums.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Kernel enums — enums the X++ runtime defines, with NO AOT metadata element.
+ *
+ * These are referenced by ordinary metadata (`<EnumType>NoYes</EnumType>` appears
+ * 48 times in CustTable.xml alone, and EDT NoYesId reports `Enum Type: NoYes`)
+ * but they have no `AxEnum/*.xml` anywhere, so no metadata-backed lookup can
+ * ever prove them: not the C# bridge (`IMetadataProvider.Enums` does not carry
+ * them), not the SQLite symbol index (it indexes AOT XML), not a disk probe.
+ *
+ * Treating "absent from the AOT" as "does not exist" produced two failures, both
+ * confirmed live on 2026-08-24:
+ *
+ *   1. `validate_code(mode="references", codeType="xml-table")` reported
+ *      `<EnumType>NoYes</EnumType>` as a hard ERROR — "Enum NoYes not found in
+ *      the symbol index" — under "Fix errors before writing — these will cause
+ *      compiler failures". An agent obeying that edits correct metadata, and
+ *      `search` offers it NoYesBlank / DefaultNoYes / NoYesCombo to "correct" to.
+ *      Those enums are real, so the result compiles clean and means the wrong
+ *      thing.
+ *   2. `get_object_info(objectType="enum", name="NoYes")` answered "not found via
+ *      bridge, symbol index, or on disk" and advised searching other spellings,
+ *      running update_symbol_index on `NoYes.xml`, and checking
+ *      D365FO_CUSTOM_PACKAGES_PATH. None of that can ever succeed: there is no
+ *      file to index. Meanwhile the EDT reader hands the agent the name `NoYes`
+ *      in the first place — a loop with no exit.
+ *
+ * The X++ reference resolver already knew this (resolveReferences.ts allow-listed
+ * 'noyes' and 'exception' for exactly this reason), which is why X++ using
+ * `NoYes::Yes` validated cleanly while the XML path hard-errored on the same
+ * enum. This module is that knowledge in one place, so the next path to need it
+ * does not have to rediscover it.
+ *
+ * MEMBERSHIP IS EVIDENCE-BASED, not remembered: every name below was checked
+ * against the complete set of 8,220 `AxEnum/*.xml` basenames in
+ * K:\AosService\PackagesLocalDirectory (metamodel 7.0.7996.33) and is absent
+ * from all of them.
+ */
+/** A kernel enum, and the value names it is used with. */
+export interface KernelEnum {
+    /** Canonical casing, for rendering. */
+    name: string;
+    /**
+     * Value names as OBSERVED in shipped X++/metadata under
+     * PackagesLocalDirectory. Deliberately not claimed to be exhaustive — it is
+     * what the product itself uses. Omitted where a scan found no usage, rather
+     * than filled in from memory.
+     */
+    values?: string[];
+}
+/** Lowercase names, for the allow-lists that already work in lowercase. */
+export declare const KERNEL_ENUM_NAMES: ReadonlySet<string>;
+/** Is `name` an enum the runtime defines rather than the AOT? Case-insensitive. */
+export declare function isKernelEnum(name: string | null | undefined): boolean;
+/** The entry for `name`, or undefined when it is not a kernel enum. */
+export declare function getKernelEnum(name: string | null | undefined): KernelEnum | undefined;
+/**
+ * The answer a reader should give instead of "not found".
+ *
+ * States the one thing the caller has to know — there is nothing to index, and
+ * references to it are valid — so the reply cannot be read as "this name is
+ * wrong, go find the right one".
+ */
+export declare function describeKernelEnum(name: string): string | null;
+//# sourceMappingURL=kernelEnums.d.ts.map

package/dist/knowledge/kernelEnums.js

@@ -0,0 +1,104 @@
+/**
+ * Kernel enums — enums the X++ runtime defines, with NO AOT metadata element.
+ *
+ * These are referenced by ordinary metadata (`<EnumType>NoYes</EnumType>` appears
+ * 48 times in CustTable.xml alone, and EDT NoYesId reports `Enum Type: NoYes`)
+ * but they have no `AxEnum/*.xml` anywhere, so no metadata-backed lookup can
+ * ever prove them: not the C# bridge (`IMetadataProvider.Enums` does not carry
+ * them), not the SQLite symbol index (it indexes AOT XML), not a disk probe.
+ *
+ * Treating "absent from the AOT" as "does not exist" produced two failures, both
+ * confirmed live on 2026-08-24:
+ *
+ *   1. `validate_code(mode="references", codeType="xml-table")` reported
+ *      `<EnumType>NoYes</EnumType>` as a hard ERROR — "Enum NoYes not found in
+ *      the symbol index" — under "Fix errors before writing — these will cause
+ *      compiler failures". An agent obeying that edits correct metadata, and
+ *      `search` offers it NoYesBlank / DefaultNoYes / NoYesCombo to "correct" to.
+ *      Those enums are real, so the result compiles clean and means the wrong
+ *      thing.
+ *   2. `get_object_info(objectType="enum", name="NoYes")` answered "not found via
+ *      bridge, symbol index, or on disk" and advised searching other spellings,
+ *      running update_symbol_index on `NoYes.xml`, and checking
+ *      D365FO_CUSTOM_PACKAGES_PATH. None of that can ever succeed: there is no
+ *      file to index. Meanwhile the EDT reader hands the agent the name `NoYes`
+ *      in the first place — a loop with no exit.
+ *
+ * The X++ reference resolver already knew this (resolveReferences.ts allow-listed
+ * 'noyes' and 'exception' for exactly this reason), which is why X++ using
+ * `NoYes::Yes` validated cleanly while the XML path hard-errored on the same
+ * enum. This module is that knowledge in one place, so the next path to need it
+ * does not have to rediscover it.
+ *
+ * MEMBERSHIP IS EVIDENCE-BASED, not remembered: every name below was checked
+ * against the complete set of 8,220 `AxEnum/*.xml` basenames in
+ * K:\AosService\PackagesLocalDirectory (metamodel 7.0.7996.33) and is absent
+ * from all of them.
+ */
+const ENTRIES = [
+    // By far the most common: boolean-ish fields reach it through EDT NoYesId.
+    { name: 'NoYes', values: ['No', 'Yes'] },
+    { name: 'Exception', values: [
+            'Break', 'CLRError', 'CodeAccessSecurity', 'DDEerror', 'Deadlock',
+            'DuplicateKeyException', 'DuplicateKeyExceptionNotRecovered', 'Error',
+            'FunctionArgument', 'Info', 'Internal', 'Sequence', 'Timeout',
+            'TransientSqlConnectionError', 'UpdateConflict',
+            'UpdateConflictNotRecovered', 'ViewDataSourceValidation', 'Warning',
+        ] },
+    { name: 'Types', values: [
+            'AnyType', 'Blob', 'Class', 'Container', 'Date', 'Enum', 'Guid', 'Int64',
+            'Integer', 'List', 'RString', 'Real', 'Record', 'String', 'Time',
+            'UserType', 'UtcDateTime', 'VarArg', 'VarString', 'Void',
+        ] },
+    { name: 'TableScope', values: ['CurrentTableOnly', 'IncludeBaseTables', 'IncludeDerivedTables'] },
+    { name: 'ConcurrencyModel', values: ['Auto', 'Optimistic', 'Pessimistic'] },
+    { name: 'StatementType', values: ['Delete', 'Insert', 'Select', 'Update'] },
+    // Real kernel enums with no usage in the packages scanned — listed without
+    // values rather than with guessed ones.
+    { name: 'IsolationLevel' },
+    { name: 'UtcDateTimeOrder' },
+    { name: 'DateOrder' },
+    { name: 'DateDay' },
+    { name: 'DateMonth' },
+    { name: 'DateYear' },
+];
+const BY_LOWER = new Map(ENTRIES.map(e => [e.name.toLowerCase(), e]));
+/** Lowercase names, for the allow-lists that already work in lowercase. */
+export const KERNEL_ENUM_NAMES = new Set(BY_LOWER.keys());
+/** Is `name` an enum the runtime defines rather than the AOT? Case-insensitive. */
+export function isKernelEnum(name) {
+    return !!name && BY_LOWER.has(name.trim().toLowerCase());
+}
+/** The entry for `name`, or undefined when it is not a kernel enum. */
+export function getKernelEnum(name) {
+    return name ? BY_LOWER.get(name.trim().toLowerCase()) : undefined;
+}
+/**
+ * The answer a reader should give instead of "not found".
+ *
+ * States the one thing the caller has to know — there is nothing to index, and
+ * references to it are valid — so the reply cannot be read as "this name is
+ * wrong, go find the right one".
+ */
+export function describeKernelEnum(name) {
+    const entry = getKernelEnum(name);
+    if (!entry)
+        return null;
+    const lines = [
+        `# Enum: ${entry.name} (kernel enum)`,
+        '',
+        `\`${entry.name}\` is defined by the X++ runtime, not by an AOT element. There is no ` +
+            `\`AxEnum/${entry.name}.xml\` in any package, so the bridge, the symbol index and a disk ` +
+            `probe all correctly fail to find one — and there is nothing to index.`,
+        '',
+        `**It is valid to reference.** \`<EnumType>${entry.name}</EnumType>\` in metadata and ` +
+            `\`${entry.name}::Value\` in X++ both compile. Do NOT substitute a similarly named AOT ` +
+            `enum (for ${entry.name === 'NoYes' ? '`NoYes`, search offers `NoYesBlank`, `NoYesCombo`, `DefaultNoYes`' : 'example, a prefixed variant'}) — those are different types.`,
+    ];
+    if (entry.values?.length) {
+        lines.push('', '## Values', '', entry.values.map(v => `- \`${entry.name}::${v}\``).join('\n'), '', '_Value names as used by shipped X++ under PackagesLocalDirectory; the kernel is the ' +
+            'authority, so treat the list as observed rather than exhaustive._');
+    }
+    return lines.join('\n');
+}
+//# sourceMappingURL=kernelEnums.js.map

package/dist/server/toolSchemas/buildD365foProject.d.ts

@@ -25,7 +25,7 @@ export declare const buildD365foProjectTool: {
                 type: string;
                 description: string;
             };
-            buildReferencedModels: {
+            bpCheck: {
                 type: string;
                 description: string;
             };

package/dist/server/toolSchemas/buildD365foProject.js

@@ -27,9 +27,9 @@ export const buildD365foProjectTool = {
                 type: 'boolean',
                 description: 'Full recompile of the TARGET model only (deps stay incremental). Use when xppc reports stale symbol errors.',
             },
-            buildReferencedModels: {
+            bpCheck: {
                 type: 'boolean',
-                description: 'DISABLED — always ignored. Rebuilding dependency models on every build slows the run down and referenced models are expected to already be compiled.',
+                description: 'On a SUCCESSFUL build, also run the best-practice checker and append its findings — saves the usual follow-up run_bp_check call.',
             },
             wait: {
                 type: 'boolean',