d365fo-mcp 1.2.0 → 1.4.0

package/README.md

@@ -10,7 +10,7 @@
 [![TypeScript](https://img.shields.io/badge/TypeScript-6.0-blue.svg)](https://www.typescriptlang.org/)
 [![Tests](https://img.shields.io/badge/tests-1400%2B-brightgreen.svg)](docs/TESTING.md)
 <!-- coverage-badge:start -->
-[![Core coverage](https://img.shields.io/badge/core_coverage-100%25-brightgreen.svg)](eval/COVERAGE.md) [![Total coverage](https://img.shields.io/badge/total_coverage-59.7%25-lightgrey.svg)](eval/COVERAGE.md)
+[![Core coverage](https://img.shields.io/badge/core_coverage-100%25-brightgreen.svg)](eval/COVERAGE.md) [![Total coverage](https://img.shields.io/badge/total_coverage-64.9%25-lightgrey.svg)](eval/COVERAGE.md)
 <!-- coverage-badge:end -->
 
 *Grounded AI development for Dynamics 365 Finance & Operations — works with GitHub Copilot and Claude Code*

package/bridge/D365MetadataBridge/Protocol/RequestDispatcher.cs

@@ -538,7 +538,10 @@ namespace D365MetadataBridge.Protocol
                             var relatedTable = request.GetStringParam("relatedTable")
                                 ?? throw new ArgumentException("Missing: relatedTable");
                             return _writeService!.AddRelation(tableName, relationName, relatedTable,
-                                request.GetParam<System.Collections.Generic.List<WriteRelationConstraint>>("constraints"));
+                                request.GetParam<System.Collections.Generic.List<WriteRelationConstraint>>("constraints"),
+                                request.GetStringParam("relationCardinality") ?? request.GetStringParam("cardinality"),
+                                request.GetStringParam("relatedTableCardinality"),
+                                request.GetStringParam("relationshipType"));
                         });
 
                     case "removerelation":
@@ -965,7 +968,10 @@ namespace D365MetadataBridge.Protocol
                                 writeResult = _writeService.AddRelation(objectName,
                                     S("relationName") ?? throw new ArgumentException("Missing: relationName"),
                                     S("relatedTable") ?? throw new ArgumentException("Missing: relatedTable"),
-                                    op.GetTypedParam<System.Collections.Generic.List<WriteRelationConstraint>>("constraints"));
+                                    op.GetTypedParam<System.Collections.Generic.List<WriteRelationConstraint>>("constraints"),
+                                    S("relationCardinality") ?? S("cardinality"),
+                                    S("relatedTableCardinality"),
+                                    S("relationshipType"));
                                 break;
 
                             case "removerelation":

package/bridge/D365MetadataBridge/Services/MetadataWriteService.cs

@@ -224,11 +224,14 @@ namespace D365MetadataBridge.Services
 
             var axTable = new AxTable { Name = name };
 
-            // Apply table-level properties (Label, TableGroup, CacheLookup, etc.)
+            // Apply table-level properties (Label, TableGroup, CacheLookup, etc.).
+            // Finding #35: an unknown key was dropped in silence — report it instead.
+            var unsupportedProperties = new List<string>();
             if (properties != null)
             {
                 foreach (var kv in properties)
-                    SetAxTableProperty(axTable, kv.Key, kv.Value);
+                    if (!SetAxTableProperty(axTable, kv.Key, kv.Value))
+                        unsupportedProperties.Add(kv.Key);
             }
 
             // Add fields
@@ -318,7 +321,14 @@ namespace D365MetadataBridge.Services
             tableProvider.Create(axTable, msi);
 
             var filePath = GetExpectedPath("AxTable", name, modelName);
-            return new { success = true, objectType = "table", objectName = name, modelName, filePath, api = "IMetaTableProvider.Create" };
+            return new
+            {
+                success = true, objectType = "table", objectName = name, modelName, filePath,
+                api = "IMetaTableProvider.Create",
+                appliedProperties = (properties?.Keys ?? Enumerable.Empty<string>())
+                    .Where(k => !unsupportedProperties.Contains(k)).ToList(),
+                unsupportedProperties,
+            };
         }
 
         /// <summary>
@@ -549,10 +559,15 @@ namespace D365MetadataBridge.Services
             }
 
             // ── Apply any extra properties (overrides auto-set values if needed) ──
+            // Finding #35: the return value used to be thrown away, so an unknown key
+            // (configurationKey, …) produced a stderr line nobody reads and a ✅ to the
+            // caller. Collect what did NOT apply and report it in the response.
+            var unsupportedProperties = new List<string>();
             if (extraProperties != null)
             {
                 foreach (var kv in extraProperties)
-                    SetAxTableProperty(axTable, kv.Key, kv.Value);
+                    if (!SetAxTableProperty(axTable, kv.Key, kv.Value))
+                        unsupportedProperties.Add(kv.Key);
             }
 
             // ── Write to disk via IMetadataProvider ──
@@ -569,6 +584,9 @@ namespace D365MetadataBridge.Services
                 modelName,
                 filePath,
                 api = "IMetaTableProvider.Create (Smart)",
+                appliedProperties = (extraProperties?.Keys ?? Enumerable.Empty<string>())
+                    .Where(k => !unsupportedProperties.Contains(k)).ToList(),
+                unsupportedProperties,
                 bpDefaults = new
                 {
                     cacheLookup = axTable.CacheLookup.ToString(),
@@ -1123,7 +1141,8 @@ namespace D365MetadataBridge.Services
         /// AxFormDataSourceConcrete subtype can yield AxFormDataSourceReferenced (used for
         /// nested/referenced sources), which AxForm.AddDataSource then fails to cast.
         /// </summary>
-        private AxFormDataSourceConcrete CreateFormDataSourceRoot(string dsName, string table, string? joinSource)
+        private AxFormDataSourceConcrete CreateFormDataSourceRoot(string dsName, string table, string? joinSource,
+            string? linkType = null)
         {
             var assembly = typeof(AxClass).Assembly;
             var dsType = assembly.GetType("Microsoft.Dynamics.AX.Metadata.MetaModel.AxFormDataSourceRoot")
@@ -1136,9 +1155,51 @@ namespace D365MetadataBridge.Services
             ds.Name = dsName;
             ds.Table = table;
             if (!string.IsNullOrEmpty(joinSource)) ds.JoinSource = joinSource;
+            // LinkType used to be accepted by the caller and then dropped here, so a join
+            // reported success and serialised without it (findings #35).
+            SetEnumProperty((object)ds, "LinkType", linkType);
             return (AxFormDataSourceConcrete)ds;
         }
 
+        /// <summary>
+        /// Sets an enum-typed metamodel property from its string name, reflectively.
+        ///
+        /// The metamodel spells these as generated enums (DataSourceLinkType_ITxt,
+        /// Cardinality, RelationshipType …) whose members are the only legal values, so a
+        /// typo cannot be written — but it must not be swallowed either. An unparseable
+        /// value throws with the full member list rather than leaving the property at its
+        /// default, which is exactly how these parameters went missing before: accepted,
+        /// dropped, reported as success.
+        ///
+        /// A null/empty value is a no-op (the caller did not ask for the property).
+        /// </summary>
+        private static void SetEnumProperty(object target, string propertyName, string? value)
+        {
+            if (string.IsNullOrWhiteSpace(value)) return;
+
+            var prop = target.GetType().GetProperty(propertyName)
+                ?? throw new InvalidOperationException(
+                    $"{target.GetType().Name} has no '{propertyName}' property in this metamodel build " +
+                    $"({BuildInfo.MetamodelFileVersion}).");
+            var enumType = Nullable.GetUnderlyingType(prop.PropertyType) ?? prop.PropertyType;
+            if (!enumType.IsEnum)
+                throw new InvalidOperationException(
+                    $"{target.GetType().Name}.{propertyName} is {enumType.Name}, not an enum.");
+
+            object parsed;
+            try
+            {
+                parsed = Enum.Parse(enumType, value!.Trim(), ignoreCase: true);
+            }
+            catch (ArgumentException)
+            {
+                throw new ArgumentException(
+                    $"'{value}' is not a valid {propertyName}. Valid values: " +
+                    string.Join(", ", Enum.GetNames(enumType)) + ".");
+            }
+            prop.SetValue(target, parsed);
+        }
+
         /// <summary>
         /// Creates a new AxMenu via DiskProvider.
         /// </summary>
@@ -1443,7 +1504,7 @@ namespace D365MetadataBridge.Services
                         ?? throw new ArgumentException($"Table '{objectName}' not found");
                     var msi = GetModelSaveInfoForObject(_provider.Tables, objectName);
                     if (!SetAxTableProperty(obj, propertyPath, propertyValue))
-                        throw new ArgumentException($"Unknown AxTable property '{propertyPath}' — nothing was written. Supported: label, developerDocumentation, tableGroup, cacheLookup, clusteredIndex, primaryIndex, replacementKey, saveDataPerCompany, tableType, supportInheritance, instanceRelationType, extends, titleField1, titleField2.");
+                        throw new ArgumentException($"Unknown AxTable property '{propertyPath}' — nothing was written. Supported: label, developerDocumentation, configurationKey, formRef, tableGroup, cacheLookup, clusteredIndex, primaryIndex, replacementKey, saveDataPerCompany, tableType, supportInheritance, instanceRelationType, extends, titleField1, titleField2.");
                     ((IMetaTableProvider)_provider.Tables).Update(obj, msi);
                     return new { success = true, operation = "modify-property", objectType, objectName, propertyPath, propertyValue, api = "Update" };
                 }
@@ -1808,14 +1869,30 @@ namespace D365MetadataBridge.Services
         // TABLE RELATION OPERATIONS
         // ========================
 
-        /// <summary>Adds a relation to a table.</summary>
-        public object AddRelation(string tableName, string relationName, string relatedTable, List<WriteRelationConstraint>? constraints)
+        /// <summary>
+        /// Adds a relation to a table.
+        ///
+        /// Cardinality / RelatedTableCardinality / RelationshipType are real
+        /// AxTableRelation properties (verified against this VM's metamodel), but this
+        /// method used to set only Name, RelatedTable and the constraints — so a relation
+        /// reported "✅ added" and then failed BP with
+        /// BPErrorTableRelationshipPropertiesCompleteness naming exactly those three
+        /// (findings #5 / #35). The TS side patched them onto the XML afterwards as a
+        /// workaround; writing them through the provider is what puts them in the
+        /// serialiser's own element order instead of a hand-anchored one.
+        /// </summary>
+        public object AddRelation(string tableName, string relationName, string relatedTable,
+            List<WriteRelationConstraint>? constraints,
+            string? cardinality = null, string? relatedTableCardinality = null, string? relationshipType = null)
         {
             var axTable = _provider.Tables.Read(tableName)
                 ?? throw new ArgumentException($"Table '{tableName}' not found");
             var msi = GetModelSaveInfoForObject(_provider.Tables, tableName);
 
             var axRel = new AxTableRelation { Name = relationName, RelatedTable = relatedTable };
+            SetEnumProperty(axRel, "Cardinality", cardinality);
+            SetEnumProperty(axRel, "RelatedTableCardinality", relatedTableCardinality);
+            SetEnumProperty(axRel, "RelationshipType", relationshipType);
             if (constraints != null)
             {
                 foreach (var c in constraints)
@@ -1831,7 +1908,14 @@ namespace D365MetadataBridge.Services
             axTable.AddRelation(axRel);
 
             ((IMetaTableProvider)_provider.Tables).Update(axTable, msi);
-            return new { success = true, operation = "add-relation", objectName = tableName, relationName, relatedTable, api = "IMetaTableProvider.Update" };
+            return new
+            {
+                success = true, operation = "add-relation", objectName = tableName, relationName, relatedTable,
+                cardinality = axRel.Cardinality.ToString(),
+                relatedTableCardinality = axRel.RelatedTableCardinality.ToString(),
+                relationshipType = axRel.RelationshipType.ToString(),
+                api = "IMetaTableProvider.Update",
+            };
         }
 
         /// <summary>Removes a relation from a table.</summary>
@@ -1941,13 +2025,15 @@ namespace D365MetadataBridge.Services
                 }
                 if (target == null)
                     throw new InvalidOperationException($"Field '{fieldName}' not found on table '{tableName}'");
+                var applied = new List<string>();
                 if (properties != null)
                 {
                     foreach (var kv in properties)
-                        SetTableFieldProperty(target, kv.Key, kv.Value);
+                        if (SetTableFieldProperty(target, kv.Key, kv.Value)) applied.Add(kv.Key);
                 }
+                RequireSomethingApplied("modify-field", tableName, fieldName, properties, applied, SupportedTableFieldProperties);
                 ((IMetaTableProvider)_provider.Tables).Update(axTable, msi);
-                return new { success = true, operation = "modify-field", objectName = tableName, fieldName, api = "IMetaTableProvider.Update" };
+                return new { success = true, operation = "modify-field", objectName = tableName, fieldName, applied, api = "IMetaTableProvider.Update" };
             }
 
             var axExt = _provider.TableExtensions.Read(tableName);
@@ -1962,15 +2048,17 @@ namespace D365MetadataBridge.Services
                 }
                 if (target == null)
                     throw new InvalidOperationException($"Field '{fieldName}' not found on table-extension '{tableName}'");
+                var applied = new List<string>();
                 if (properties != null)
                 {
                     foreach (var kv in properties)
-                        SetTableFieldProperty(target, kv.Key, kv.Value);
+                        if (SetTableFieldProperty(target, kv.Key, kv.Value)) applied.Add(kv.Key);
                 }
+                RequireSomethingApplied("modify-field", tableName, fieldName, properties, applied, SupportedTableFieldProperties);
                 var extProvider = _provider.TableExtensions as IMetaTableExtensionProvider
                     ?? throw new InvalidOperationException("IMetaTableExtensionProvider not available");
                 extProvider.Update(axExt, msi);
-                return new { success = true, operation = "modify-field", objectName = tableName, fieldName, api = "IMetaTableExtensionProvider.Update" };
+                return new { success = true, operation = "modify-field", objectName = tableName, fieldName, applied, api = "IMetaTableExtensionProvider.Update" };
             }
 
             throw new ArgumentException($"Table or table-extension '{tableName}' not found");
@@ -2183,23 +2271,33 @@ namespace D365MetadataBridge.Services
             if (target == null)
                 throw new InvalidOperationException($"Enum value '{valueName}' not found on enum '{enumName}'");
 
+            var applied = new List<string>();
             if (properties != null)
             {
                 foreach (var kv in properties)
                 {
                     switch (kv.Key.ToLowerInvariant())
                     {
-                        case "label": target.Label = kv.Value; break;
+                        case "label": target.Label = kv.Value; applied.Add(kv.Key); break;
                         case "value":
-                            if (int.TryParse(kv.Value, out var iv)) target.Value = iv;
+                            if (int.TryParse(kv.Value, out var iv)) { target.Value = iv; applied.Add(kv.Key); }
+                            break;
+                        case "name": target.Name = kv.Value; applied.Add(kv.Key); break;
+                        case "countryregioncodes": target.CountryRegionCodes = kv.Value; applied.Add(kv.Key); break;
+                        case "configurationkey": target.ConfigurationKey = kv.Value; applied.Add(kv.Key); break;
+                        default:
+                            Console.Error.WriteLine($"[WriteService] Unknown enum value property: {kv.Key}");
                             break;
-                        case "name": target.Name = kv.Value; break;
                     }
                 }
             }
+            // helpText is deliberately absent: AxEnumValue has no HelpText in the
+            // metamodel (only AxEnum does), so there is nothing to write it to.
+            RequireSomethingApplied("modify-enum-value", enumName, valueName, properties, applied,
+                new[] { "label", "value", "name", "countryRegionCodes", "configurationKey" });
 
             ((IMetaEnumProvider)_provider.Enums).Update(axEnum, msi);
-            return new { success = true, operation = "modify-enum-value", objectName = enumName, valueName, api = "IMetaEnumProvider.Update" };
+            return new { success = true, operation = "modify-enum-value", objectName = enumName, valueName, applied, api = "IMetaEnumProvider.Update" };
         }
 
         /// <summary>Removes a value from an enum.</summary>
@@ -2409,10 +2507,10 @@ namespace D365MetadataBridge.Services
                             return new { success = true, operation = "add-data-source", objectType, objectName, dsName, table, skipped = true, reason = $"data source '{(string)dyn.Name}' already binds table '{table}'", api = "IMetaFormProvider.Update" };
                     }
 
-                    axForm.AddDataSource(CreateFormDataSourceRoot(dsName, table, joinSource));
+                    axForm.AddDataSource(CreateFormDataSourceRoot(dsName, table, joinSource, linkType));
 
                     ((IMetaFormProvider)_provider.Forms).Update(axForm, msi);
-                    return new { success = true, operation = "add-data-source", objectType, objectName, dsName, table, api = "IMetaFormProvider.Update" };
+                    return new { success = true, operation = "add-data-source", objectType, objectName, dsName, table, joinSource, linkType, api = "IMetaFormProvider.Update" };
                 }
                 default:
                     throw new ArgumentException($"add-data-source not supported for objectType '{objectType}' via bridge");
@@ -2518,13 +2616,25 @@ namespace D365MetadataBridge.Services
             {
                 case "label": tbl.Label = value; break;
                 case "developerdocumentation": tbl.DeveloperDocumentation = value; break;
+                // ConfigurationKey / FormRef were missing here, so EVERY writer that
+                // funnels through this switch (CreateTable, CreateSmartTable,
+                // modify-property) discarded them while answering success — the table
+                // half of finding #35. Both are plain string properties on AxTable.
+                case "configurationkey": tbl.ConfigurationKey = value; break;
+                case "formref": tbl.FormRef = value; break;
                 case "tablegroup":
-                    if (Enum.TryParse<Microsoft.Dynamics.AX.Metadata.Core.MetaModel.TableGroup>(value, true, out var tg))
-                        tbl.TableGroup = tg;
+                    if (!Enum.TryParse<Microsoft.Dynamics.AX.Metadata.Core.MetaModel.TableGroup>(value, true, out var tg))
+                        throw new ArgumentException(
+                            $"'{value}' is not a valid TableGroup. Valid values: " +
+                            string.Join(", ", Enum.GetNames(typeof(Microsoft.Dynamics.AX.Metadata.Core.MetaModel.TableGroup))) + ".");
+                    tbl.TableGroup = tg;
                     break;
                 case "cachelookup":
-                    if (Enum.TryParse<Microsoft.Dynamics.AX.Metadata.Core.MetaModel.RecordCacheLevel>(value, true, out var cl))
-                        tbl.CacheLookup = cl;
+                    if (!Enum.TryParse<Microsoft.Dynamics.AX.Metadata.Core.MetaModel.RecordCacheLevel>(value, true, out var cl))
+                        throw new ArgumentException(
+                            $"'{value}' is not a valid CacheLookup. Valid values: " +
+                            string.Join(", ", Enum.GetNames(typeof(Microsoft.Dynamics.AX.Metadata.Core.MetaModel.RecordCacheLevel))) + ".");
+                    tbl.CacheLookup = cl;
                     break;
                 case "clusteredindex": tbl.ClusteredIndex = value; break;
                 case "primaryindex": tbl.PrimaryIndex = value; break;
@@ -2533,8 +2643,11 @@ namespace D365MetadataBridge.Services
                     tbl.SaveDataPerCompany = ParseNoYes(value);
                     break;
                 case "tabletype":
-                    if (Enum.TryParse<Microsoft.Dynamics.AX.Metadata.Core.MetaModel.TableType>(value, true, out var tt))
-                        tbl.TableType = tt;
+                    if (!Enum.TryParse<Microsoft.Dynamics.AX.Metadata.Core.MetaModel.TableType>(value, true, out var tt))
+                        throw new ArgumentException(
+                            $"'{value}' is not a valid TableType. Valid values: " +
+                            string.Join(", ", Enum.GetNames(typeof(Microsoft.Dynamics.AX.Metadata.Core.MetaModel.TableType))) + ".");
+                    tbl.TableType = tt;
                     break;
                 case "supportinheritance":
                     tbl.SupportInheritance = ParseNoYes(value);
@@ -2926,34 +3039,67 @@ namespace D365MetadataBridge.Services
         }
 
         /// <summary>Sets a property on an existing table field.</summary>
-        private void SetTableFieldProperty(AxTableField field, string prop, string value)
+        /// <summary>Table-field properties SetTableFieldProperty knows how to write.</summary>
+        private static readonly string[] SupportedTableFieldProperties =
+            { "label", "helpText", "mandatory", "allowEdit", "extendedDataType", "stringSize", "enumType" };
+
+        /// <summary>
+        /// Applies one field property. Returns false when the key is unknown, or when it
+        /// is known but does not apply to THIS field type (stringSize on an enum field) —
+        /// the caller turns "nothing applied" into an error instead of a hollow success.
+        /// </summary>
+        private bool SetTableFieldProperty(AxTableField field, string prop, string value)
         {
             switch (prop.ToLowerInvariant())
             {
-                case "label": field.Label = value; break;
-                case "helptext": field.HelpText = value; break;
+                case "label": field.Label = value; return true;
+                case "helptext": field.HelpText = value; return true;
                 case "mandatory":
                     field.Mandatory = ParseNoYes(value);
-                    break;
+                    return true;
                 case "allowedit":
                     field.AllowEdit = ParseNoYes(value);
-                    break;
+                    return true;
                 case "extendeddatatype":
                 case "edt":
                     field.ExtendedDataType = value;
-                    break;
+                    return true;
                 case "stringsize":
-                    if (field is AxTableFieldString sf && int.TryParse(value, out var ss)) sf.StringSize = ss;
-                    break;
+                    if (field is AxTableFieldString sf && int.TryParse(value, out var ss)) { sf.StringSize = ss; return true; }
+                    return false;
                 case "enumtype":
-                    if (field is AxTableFieldEnum ef) ef.EnumType = value;
-                    break;
+                    if (field is AxTableFieldEnum ef) { ef.EnumType = value; return true; }
+                    return false;
                 default:
                     Console.Error.WriteLine($"[WriteService] Unknown table field property: {prop}");
-                    break;
+                    return false;
             }
         }
 
+        /// <summary>
+        /// Turns a property bag that changed nothing into an error.
+        ///
+        /// Every modify-* op here read its properties, applied whatever it recognised,
+        /// called Update() and returned success — so a caller who sent the parameters in
+        /// the wrong shape (flat instead of nested under `properties`), or a key this
+        /// build does not support, got "✅ modified" over a byte-identical file. The
+        /// modify surface must not report a write it did not make.
+        /// </summary>
+        private static void RequireSomethingApplied(
+            string operation, string objectName, string targetName,
+            Dictionary<string, string>? properties, List<string> applied, IEnumerable<string> supported)
+        {
+            if (applied.Count > 0) return;
+            if (properties == null || properties.Count == 0)
+                throw new ArgumentException(
+                    $"{operation} on '{objectName}.{targetName}' was given no properties, so it would " +
+                    $"change nothing. Pass them under `properties`, e.g. " +
+                    $"properties: {{ \"{supported.First()}\": \"…\" }}. Supported: {string.Join(", ", supported)}.");
+            throw new ArgumentException(
+                $"{operation} on '{objectName}.{targetName}' changed nothing: none of " +
+                $"[{string.Join(", ", properties.Keys)}] could be applied. Supported: {string.Join(", ", supported)}.");
+        }
+
         /// <summary>
         /// Recursively finds a control in the form design tree by name.
         /// Returns the dynamic control object (AxFormControl subclass).

package/dist/bridge/bridgeAdapter.d.ts

@@ -22,6 +22,22 @@ export interface ToolResult {
 }
 export declare function tryBridgeTable(bridge: BridgeClient | undefined, tableName: string, methodOffset?: number): Promise<ToolResult | null>;
 export declare function tryBridgeClass(bridge: BridgeClient | undefined, className: string, compact: boolean, methodOffset?: number): Promise<ToolResult | null>;
+/**
+ * The one-line signature shown per method in the compact class view.
+ *
+ * This used to be `source.split('\n')[0]`, which for any method whose body opens
+ * with an XML doc comment rendered the METHOD NAME as `/// <summary>`: on
+ * Foundation's CustVendVoucher, 14 of the first 15 methods came out that way
+ * (L2-datetime-timezone-range run). Every documented platform class was
+ * therefore unreadable through the default grounding path, while the sibling
+ * `options={members:"names"}` path answered correctly.
+ *
+ * The declaration is located with the shared X++ parser, which handles
+ * parameter lists wrapped across lines; only if that fails do we fall back to
+ * the first line that is neither blank, nor a comment, nor an attribute — and
+ * finally to the name the metadata itself carries, which is never wrong.
+ */
+export declare function methodSignatureLine(name: string, source?: string): string;
 export declare function tryBridgeMethodSource(bridge: BridgeClient | undefined, className: string, methodName: string): Promise<ToolResult | null>;
 export declare function tryBridgeEnum(bridge: BridgeClient | undefined, enumName: string): Promise<ToolResult | null>;
 export declare function tryBridgeEdt(bridge: BridgeClient | undefined, edtName: string): Promise<ToolResult | null>;
@@ -55,6 +71,18 @@ export interface BridgeSearchOptions {
         name: string;
         type: string;
     }>;
+    /**
+     * Keyword hits from CUSTOM/ISV models the caller resolved from the SQLite
+     * index (model-scoped, FTS-driven). The bridge enumerates a single merged
+     * key list dominated by Microsoft standard objects and truncates at
+     * maxResults, so custom matches that enumerate later never reach the client.
+     * These are spliced in and ranked directly after the exact matches (ahead of
+     * Microsoft standard hits) so custom code is always visible.
+     */
+    customMatches?: Array<{
+        name: string;
+        type: string;
+    }>;
 }
 export declare function tryBridgeSearch(bridge: BridgeClient | undefined, query: string, objectType?: string, maxResults?: number, opts?: BridgeSearchOptions): Promise<ToolResult | null>;
 export declare function tryBridgeQuery(bridge: BridgeClient | undefined, queryName: string): Promise<ToolResult | null>;
@@ -194,9 +222,14 @@ export declare function bridgeRemoveIndex(bridge: BridgeClient | undefined, tabl
 export declare function bridgeAddRelation(bridge: BridgeClient | undefined, tableName: string, relationName: string, relatedTable: string, constraints?: Array<{
     field?: string;
     relatedField?: string;
-}>): Promise<{
+}>, properties?: {
+    relationCardinality?: string;
+    relatedTableCardinality?: string;
+    relationshipType?: string;
+}): Promise<{
     success: boolean;
     message: string;
+    propertiesWritten?: boolean;
 } | null>;
 /**
  * Removes a relation from a table via the C# bridge.

package/dist/bridge/bridgeAdapter.js

@@ -13,7 +13,8 @@
 import * as debouncedRefresh from './debouncedRefresh.js';
 import { debugLog } from '../utils/logger.js';
 import { reindentXppSource } from '../utils/xppFormat.js';
-import { rankExactFirst, isExactNameMatch } from '../utils/exactMatchRanking.js';
+import { parseXppDeclaration } from '../metadata/xppDeclaration.js';
+import { rankCustomFirst, isExactNameMatch } from '../utils/exactMatchRanking.js';
 // TABLE
 const TABLE_METHOD_PAGE_SIZE = 25;
 export async function tryBridgeTable(bridge, tableName, methodOffset = 0) {
@@ -117,6 +118,38 @@ export async function tryBridgeClass(bridge, className, compact, methodOffset =
         return null;
     }
 }
+/**
+ * The one-line signature shown per method in the compact class view.
+ *
+ * This used to be `source.split('\n')[0]`, which for any method whose body opens
+ * with an XML doc comment rendered the METHOD NAME as `/// <summary>`: on
+ * Foundation's CustVendVoucher, 14 of the first 15 methods came out that way
+ * (L2-datetime-timezone-range run). Every documented platform class was
+ * therefore unreadable through the default grounding path, while the sibling
+ * `options={members:"names"}` path answered correctly.
+ *
+ * The declaration is located with the shared X++ parser, which handles
+ * parameter lists wrapped across lines; only if that fails do we fall back to
+ * the first line that is neither blank, nor a comment, nor an attribute — and
+ * finally to the name the metadata itself carries, which is never wrong.
+ */
+export function methodSignatureLine(name, source) {
+    if (!source)
+        return name;
+    const decl = parseXppDeclaration(source, name);
+    if (decl) {
+        const params = decl.parameters
+            .map(p => `${p.type} ${p.name}${p.defaultValue ? ` = ${p.defaultValue}` : ''}`)
+            .join(', ');
+        const mods = decl.modifiers.length ? `${decl.modifiers.join(' ')} ` : '';
+        return `${mods}${decl.returnType} ${decl.name}(${params})`;
+    }
+    const firstCode = source
+        .split('\n')
+        .map(l => l.trim())
+        .find(l => l && !l.startsWith('///') && !l.startsWith('//') && !l.startsWith('/*') && !l.startsWith('*') && !l.startsWith('['));
+    return firstCode || name;
+}
 function formatClass(cls, compact, methodOffset) {
     const modifiers = [];
     if (cls.isFinal)
@@ -145,9 +178,7 @@ function formatClass(cls, compact, methodOffset) {
     out += `)\n\n`;
     for (const m of visible) {
         if (compact) {
-            // Signature-only: extract first line of source for signature
-            const sig = m.source ? m.source.split('\n')[0].trim() : m.name;
-            out += `- \`${sig}\`\n`;
+            out += `- \`${methodSignatureLine(m.name, m.source)}\`\n`;
         }
         else {
             out += `### ${m.name}\n\n`;
@@ -609,11 +640,27 @@ export async function tryBridgeSearch(bridge, query, objectType, maxResults = 50
             known.add(`${cand.name.toLowerCase()}${cand.type}`);
             spliced.push({ ...cand, fromIndex: true });
         }
-        const merged = [...spliced, ...bridgeHits];
+        const key = (n, t) => `${n.toLowerCase()} ${t}`;
+        const exactKeys = new Set(spliced.map(s => key(s.name, s.type)));
+        const bridgeKeys = new Set(bridgeHits.map(r => key(r.name, r.type)));
+        // Custom/ISV matches truncated out of the Microsoft-dominated bridge window:
+        // splice the ones the window missed and flag them so they rank ahead of
+        // Microsoft standard hits (see BridgeSearchOptions.customMatches).
+        const customKeys = new Set((opts?.customMatches ?? []).map(c => key(c.name, c.type)));
+        const customSpliced = (opts?.customMatches ?? [])
+            .filter(c => !exactKeys.has(key(c.name, c.type)) && !bridgeKeys.has(key(c.name, c.type)))
+            .map(c => ({ name: c.name, type: c.type, fromIndex: true, custom: true }));
+        const splicedCustom = customSpliced.length;
+        const merged = [
+            ...spliced.map(s => ({ ...s })),
+            ...customSpliced,
+            ...bridgeHits.map(r => ({ name: r.name, type: r.type, custom: customKeys.has(key(r.name, r.type)) })),
+        ];
         if (merged.length === 0)
             return null;
         // Exact name matches first — the bridge itself returns provider order (#15).
-        const ranked = rankExactFirst(query, merged, r => r.name).slice(0, Math.max(maxResults, spliced.length));
+        const ranked = rankCustomFirst(query, merged, r => r.name, r => !!r.custom)
+            .slice(0, Math.max(maxResults, spliced.length + splicedCustom));
         let out = `# Search: "${query}"${objectType ? ` (type: ${objectType})` : ''}\n\n`;
         out += `**Results:** ${ranked.length}\n`;
         out += `_Source: C# bridge (IMetadataProvider)_\n\n`;
@@ -625,6 +672,10 @@ export async function tryBridgeSearch(bridge, query, objectType, maxResults = 50
             out += `\n_${spliced.length} exact match(es) came from the SQLite symbol index — ` +
                 `the bridge's result window (maxResults=${maxResults}) did not contain them._\n`;
         }
+        if (splicedCustom > 0) {
+            out += `\n_${splicedCustom} custom/ISV-model match(es) were spliced in from the ` +
+                `SQLite symbol index and prioritized (bridge window maxResults=${maxResults} had truncated them)._\n`;
+        }
         return { content: [{ type: 'text', text: out }] };
     }
     catch (e) {
@@ -1009,6 +1060,9 @@ const BRIDGE_MODIFY_OPS = new Set([
     'add-field', 'modify-field', 'rename-field', 'replace-all-fields', 'remove-field',
     'add-index', 'remove-index',
     'add-relation', 'remove-relation',
+    // No C# op backs these — they are served by a direct-XML writer, but they still
+    // pass through the same modify gate.
+    'add-delete-action', 'remove-delete-action',
     'add-field-group', 'remove-field-group', 'add-field-to-field-group',
     'modify-property',
     'add-enum-value', 'modify-enum-value', 'remove-enum-value',
@@ -1249,15 +1303,23 @@ export async function bridgeRemoveIndex(bridge, tableName, indexName) {
 /**
  * Adds a relation to a table via the C# bridge.
  */
-export async function bridgeAddRelation(bridge, tableName, relationName, relatedTable, constraints) {
+export async function bridgeAddRelation(bridge, tableName, relationName, relatedTable, constraints, properties) {
     if (!bridge?.isReady || !bridge.metadataAvailable)
         return null;
     try {
-        const result = await bridge.addRelation(tableName, relationName, relatedTable, constraints);
+        const result = await bridge.addRelation(tableName, relationName, relatedTable, constraints, properties);
+        // An older bridge binary silently ignores the extra params; it echoes back only
+        // what it set, so the response says whether the on-disk fallback is still needed.
+        const r = result;
+        const propertiesWritten = typeof r.relationshipType === 'string';
         return {
             success: result.success,
+            propertiesWritten,
             message: result.success
-                ? `✅ Relation '${relationName}' added via ${result.api}`
+                ? `✅ Relation '${relationName}' added via ${result.api}` +
+                    (propertiesWritten
+                        ? ` (Cardinality=${r.cardinality}, RelatedTableCardinality=${r.relatedTableCardinality}, RelationshipType=${r.relationshipType})`
+                        : '')
                 : `Bridge addRelation returned success=false`,
         };
     }

package/dist/bridge/bridgeClient.d.ts

@@ -193,11 +193,24 @@ export declare class BridgeClient extends EventEmitter {
     addIndex(tableName: string, indexName: string, fields?: string[], allowDuplicates?: boolean, alternateKey?: boolean): Promise<BridgeWriteResult>;
     /** Remove an index from a table */
     removeIndex(tableName: string, indexName: string): Promise<BridgeWriteResult>;
-    /** Add a relation to a table */
+    /**
+     * Add a relation to a table.
+     *
+     * `properties` carries Cardinality / RelatedTableCardinality / RelationshipType —
+     * real AxTableRelation properties the bridge now sets through the provider. They
+     * used to be dropped on both sides, which is what raised
+     * BPErrorTableRelationshipPropertiesCompleteness on a relation reported as added
+     * (findings #5 / #35). An invalid value is rejected by the bridge with the list of
+     * legal ones rather than silently ignored.
+     */
     addRelation(tableName: string, relationName: string, relatedTable: string, constraints?: Array<{
         field?: string;
         relatedField?: string;
-    }>): Promise<BridgeWriteResult>;
+    }>, properties?: {
+        relationCardinality?: string;
+        relatedTableCardinality?: string;
+        relationshipType?: string;
+    }): Promise<BridgeWriteResult>;
     /** Remove a relation from a table */
     removeRelation(tableName: string, relationName: string): Promise<BridgeWriteResult>;
     /** Add a field group to a table */