d365fo-mcp 1.8.3 → 1.8.5

package/dist/scripts/build-database.js

@@ -1,6 +1,6 @@
 // src/utils/loadEnv.ts
 import dotenv from "dotenv";
-import { existsSync as existsSync2 } from "fs";
+import { existsSync as existsSync2, readFileSync as readFileSync2, statSync } from "fs";
 import { dirname as dirname2, isAbsolute as isAbsolute2, join as join2, resolve as resolve2 } from "path";
 import { fileURLToPath } from "url";
 
@@ -606,6 +606,12 @@ function defaultPathEnv(baseDir) {
 
 // src/utils/loadEnv.ts
 var PATH_VARS = ["DB_PATH", "LABELS_DB_PATH", "METADATA_PATH"];
+var WRITE_POLICY_VARS = [
+  "D365FO_ALLOW_CROSS_MODEL_WRITE",
+  "D365FO_CROSS_MODEL_WRITE_MODELS"
+];
+var writePolicySource = null;
+var writePolicyStamp = "";
 function installRootFrom(callerDir) {
   let dir = resolve2(callerDir, "..");
   for (let up = 0; up < 3; up++) {
@@ -621,6 +627,15 @@ function loadEnv(callerImportMetaUrl) {
   const callerDir = dirname2(fileURLToPath(callerImportMetaUrl));
   const envPath = process.env.ENV_FILE ? resolve2(process.env.ENV_FILE) : resolve2(installRootFrom(callerDir), ".env");
   const fromRealEnv = new Set(Object.keys(process.env));
+  writePolicySource = {
+    envPath,
+    pinned: new Set(WRITE_POLICY_VARS.filter((k) => fromRealEnv.has(k)))
+  };
+  try {
+    writePolicyStamp = String(statSync(envPath).mtimeMs);
+  } catch {
+    writePolicyStamp = "-";
+  }
   const result = dotenv.config({ path: envPath, quiet: true });
   if (result.error && !process.env.ENV_FILE) {
     dotenv.config({ quiet: true });

package/dist/scripts/build-fts.js

@@ -1,6 +1,6 @@
 // src/utils/loadEnv.ts
 import dotenv from "dotenv";
-import { existsSync as existsSync2 } from "fs";
+import { existsSync as existsSync2, readFileSync as readFileSync2, statSync } from "fs";
 import { dirname as dirname2, isAbsolute as isAbsolute2, join as join2, resolve as resolve2 } from "path";
 import { fileURLToPath } from "url";
 
@@ -606,6 +606,12 @@ function defaultPathEnv(baseDir) {
 
 // src/utils/loadEnv.ts
 var PATH_VARS = ["DB_PATH", "LABELS_DB_PATH", "METADATA_PATH"];
+var WRITE_POLICY_VARS = [
+  "D365FO_ALLOW_CROSS_MODEL_WRITE",
+  "D365FO_CROSS_MODEL_WRITE_MODELS"
+];
+var writePolicySource = null;
+var writePolicyStamp = "";
 function installRootFrom(callerDir) {
   let dir = resolve2(callerDir, "..");
   for (let up = 0; up < 3; up++) {
@@ -621,6 +627,15 @@ function loadEnv(callerImportMetaUrl) {
   const callerDir = dirname2(fileURLToPath(callerImportMetaUrl));
   const envPath = process.env.ENV_FILE ? resolve2(process.env.ENV_FILE) : resolve2(installRootFrom(callerDir), ".env");
   const fromRealEnv = new Set(Object.keys(process.env));
+  writePolicySource = {
+    envPath,
+    pinned: new Set(WRITE_POLICY_VARS.filter((k) => fromRealEnv.has(k)))
+  };
+  try {
+    writePolicyStamp = String(statSync(envPath).mtimeMs);
+  } catch {
+    writePolicyStamp = "-";
+  }
   const result = dotenv.config({ path: envPath, quiet: true });
   if (result.error && !process.env.ENV_FILE) {
     dotenv.config({ quiet: true });

package/dist/scripts/extract-metadata.js

@@ -1,6 +1,6 @@
 // src/utils/loadEnv.ts
 import dotenv from "dotenv";
-import { existsSync as existsSync2 } from "fs";
+import { existsSync as existsSync2, readFileSync as readFileSync2, statSync } from "fs";
 import { dirname as dirname2, isAbsolute as isAbsolute2, join as join2, resolve as resolve2 } from "path";
 import { fileURLToPath } from "url";
 
@@ -606,6 +606,12 @@ function defaultPathEnv(baseDir) {
 
 // src/utils/loadEnv.ts
 var PATH_VARS = ["DB_PATH", "LABELS_DB_PATH", "METADATA_PATH"];
+var WRITE_POLICY_VARS = [
+  "D365FO_ALLOW_CROSS_MODEL_WRITE",
+  "D365FO_CROSS_MODEL_WRITE_MODELS"
+];
+var writePolicySource = null;
+var writePolicyStamp = "";
 function installRootFrom(callerDir) {
   let dir = resolve2(callerDir, "..");
   for (let up = 0; up < 3; up++) {
@@ -621,6 +627,15 @@ function loadEnv(callerImportMetaUrl) {
   const callerDir = dirname2(fileURLToPath(callerImportMetaUrl));
   const envPath = process.env.ENV_FILE ? resolve2(process.env.ENV_FILE) : resolve2(installRootFrom(callerDir), ".env");
   const fromRealEnv = new Set(Object.keys(process.env));
+  writePolicySource = {
+    envPath,
+    pinned: new Set(WRITE_POLICY_VARS.filter((k) => fromRealEnv.has(k)))
+  };
+  try {
+    writePolicyStamp = String(statSync(envPath).mtimeMs);
+  } catch {
+    writePolicyStamp = "-";
+  }
   const result = dotenv.config({ path: envPath, quiet: true });
   if (result.error && !process.env.ENV_FILE) {
     dotenv.config({ quiet: true });

package/dist/server/toolSchemas/getWorkspaceInfo.js

@@ -5,13 +5,13 @@
  */
 export const getWorkspaceInfoTool = {
     name: 'get_workspace_info',
-    description: `ALWAYS call FIRST at session start. Returns model name, package path, framework directory, project path, environment type, and EXTENSION_PREFIX. Flags placeholder model names and missing prefix. Use projectName/projectPath params for solution switching. This is the authoritative source for target model — not search results.`,
+    description: `ALWAYS call FIRST at session start. Returns model name, package path, framework directory, project path, environment type, and EXTENSION_PREFIX. Flags placeholder model names and missing prefix. projectName/projectPath ONLY when the USER changed project. This is the authoritative source for target model — not search results.`,
     inputSchema: {
         type: 'object',
         properties: {
             projectName: {
                 type: 'string',
-                description: 'Preferred way to switch projects. Just the model name, e.g. "ContosoEDS" or "ContosoBank". The server resolves the full path from D365FO_SOLUTIONS_PATH automatically. Use this when the user says "switch to <project>" or opens a different solution.',
+                description: 'Only when the USER says "switch to <project>". Just the model name, e.g. "ContosoEDS"; path resolved from D365FO_SOLUTIONS_PATH. NOT a way to reach another model — reads span every model already, writes stay in the workspace model.',
             },
             projectPath: {
                 type: 'string',

package/dist/tools/createD365File.js

@@ -10,6 +10,7 @@ import { getConfigManager, fallbackPackagePath } from '../utils/configManager.js
 import { describePackagesRootScan } from '../utils/packagesRoot.js';
 import { registerCustomModel, resolveObjectPrefix, applyObjectPrefix, getObjectSuffix, applyObjectSuffix, getExtensionNamingStyle } from '../utils/modelClassifier.js';
 import { PackageResolver } from '../utils/packageResolver.js';
+import { crossModelWriteRefusal } from '../utils/crossModelWriteGuard.js';
 import { ensureXppDocComment, ensureBlankLineBeforeClosingBrace } from '../utils/xppDocGen.js';
 import { reindentXppSource } from '../utils/xppFormat.js';
 import { decodeXmlEntitiesFromXppSource } from './modifyD365File.js';
@@ -3796,6 +3797,25 @@ export async function handleCreateD365File(request, context) {
                 isError: true,
             };
         }
+        // Cross-model guard: creating INTO a custom model other than the one this
+        // workspace targets is the same mistake as modifying one — the object lands
+        // outside this project's version control and inside code other models inherit.
+        // `actualModelName` is what the write will actually use (caller's modelName, or
+        // the workspace's), so the check sits after every fallback has been applied.
+        const crossModelCreateRefusal = crossModelWriteRefusal({
+            objectName: args.objectName,
+            objectType: args.objectType,
+            owningModel: actualModelName,
+            activeModel: getConfigManager().getWriteAnchorModel() ?? '',
+            toolSwitchedModel: getConfigManager().getToolProjectSwitch()?.forcedModel ?? null,
+            action: 'create',
+        });
+        if (crossModelCreateRefusal) {
+            return {
+                content: [{ type: 'text', text: crossModelCreateRefusal }],
+                isError: true,
+            };
+        }
         // Apply extension prefix to object name
         const objectPrefix = resolveObjectPrefix(actualModelName);
         const namingStyle = getExtensionNamingStyle();

package/dist/tools/createLabel.js

@@ -17,6 +17,7 @@ import * as path from 'path';
 import { getConfigManager } from '../utils/configManager.js';
 import { defaultPackagesRoot } from '../utils/packagesRoot.js';
 import { PackageResolver } from '../utils/packageResolver.js';
+import { crossModelWriteRefusal } from '../utils/crossModelWriteGuard.js';
 import { detectEol } from '../utils/eolUtils.js';
 import { isExtensionLabelFile } from '../metadata/labelParser.js';
 import { ProjectFileManager, ProjectFileFinder } from './createD365File.js';
@@ -445,6 +446,26 @@ export async function createLabelTool(request, context) {
             resolvedPackagePath = packagePath || configManager.getPackagePath() || defaultPackagesRoot();
             resolvedPackageName = model;
         }
+        // Cross-model guard: a label file belongs to exactly one model, so writing a
+        // label into another model's file has the same consequences as editing that
+        // model's objects — and labels are usually the first thing an agent adds when
+        // it drifts into the wrong model. `model` is the model directory the write
+        // resolves to, so this compares the real target, not the caller's intent.
+        const crossModelLabelRefusal = crossModelWriteRefusal({
+            objectName: `@${args.labelFileId}:${args.labelId}`,
+            objectType: 'label',
+            owningModel: model,
+            owningPackage: resolvedPackageName,
+            activeModel: configManager.getWriteAnchorModel() ?? '',
+            toolSwitchedModel: configManager.getToolProjectSwitch()?.forcedModel ?? null,
+            action: 'create',
+        });
+        if (crossModelLabelRefusal) {
+            return {
+                content: [{ type: 'text', text: crossModelLabelRefusal }],
+                isError: true,
+            };
+        }
         const modelDir = path.join(resolvedPackagePath, resolvedPackageName, model);
         const axLabelDir = path.join(modelDir, 'AxLabelFile');
         const labelResourcesDir = path.join(axLabelDir, 'LabelResources');

package/dist/tools/d365foFileOpSpecs.js

@@ -73,7 +73,11 @@ export const D365FO_FILE_PARAM_SPECS = {
     fieldMandatory: { type: 'boolean', description: 'Mark the field Mandatory=Yes.' },
     fieldLabel: { type: 'string', description: 'Field label.' },
     fieldHelpText: { type: 'string', description: 'Field help text.' },
-    fieldEnumType: { type: 'string', description: 'Enum name to set on an enum-typed field.' },
+    fieldEnumType: {
+        type: 'string',
+        description: 'Enum name for an enum-typed field. On add-field this is all an enum field needs — ' +
+            'it writes AxTableFieldEnum + EnumType, no EDT.',
+    },
     fieldStringSize: { type: 'string', description: 'String size to set on a string-typed field.' },
     dataField: {
         type: 'string',
@@ -267,9 +271,12 @@ export const D365FO_FILE_OP_SPECS = {
     },
     'add-field': {
         required: ['fieldName'],
-        optional: ['fieldType', 'fieldBaseType', 'fieldMandatory', 'fieldLabel', 'dataField', 'dataSource', 'fieldGroupName'],
-        mutationOneOf: ['fieldType', 'dataField'],
-        note: 'Table/table-extension: fieldType (EDT) is REQUIRED. data-entity-extension: pass dataField AND ' +
+        optional: ['fieldType', 'fieldBaseType', 'fieldEnumType', 'fieldMandatory', 'fieldLabel', 'dataField', 'dataSource', 'fieldGroupName'],
+        mutationOneOf: ['fieldType', 'fieldEnumType', 'dataField'],
+        note: 'Enum field: pass fieldEnumType="<enum name>" and NO fieldType — an enum-typed table field ' +
+            'is an AxTableFieldEnum with an EnumType and needs no EDT. (fieldType is the EDT name here, ' +
+            'never an XML element name like "AxTableFieldEnum".) ' +
+            'Table/table-extension: otherwise fieldType (EDT) is REQUIRED. data-entity-extension: pass dataField AND ' +
             'dataSource instead — BOTH, or nothing is written; a mapped field has no EDT of its own, it points ' +
             'at dataField on the entity data source dataSource. fieldGroupName is optional and only applies to ' +
             'a data-entity-extension: it appends the field to that BASE-entity field group (shipped extensions ' +

package/dist/tools/generateSmartForm.js

@@ -21,6 +21,7 @@ import { methodStubsForPattern, injectMethodStubs } from '../knowledge/formPatte
 import { findBaseFormXml } from './modifyD365File.js';
 import { getFieldControlMap, getTableTitleField } from '../utils/fieldControlTypes.js';
 import { lookupSymbolNocase } from '../utils/symbolLookup.js';
+import { scaffoldWriteRefusalResult } from './writeAnchorGuard.js';
 /**
  * Symbol types a form datasource may bind to. Views are indexed as 'view'
  * (see symbolIndex.indexViews) and are legal in <Table> just like tables.
@@ -560,6 +561,15 @@ export async function handleGenerateSmartForm(args, symbolIndex) {
     if (finalName !== name) {
         console.log(`[generateSmartForm] Applied naming: ${name} → ${finalName}`);
     }
+    // See generateSmartTable: the resolved model follows the ACTIVE project, the
+    // write anchor does not. Checked before the first byte is written.
+    const anchorRefusal = scaffoldWriteRefusalResult({
+        objectName: finalName,
+        objectType: 'form',
+        targetModel: resolvedModel,
+    });
+    if (anchorRefusal)
+        return anchorRefusal;
     // Generate XML: clone an existing form (preferred) or build from a template.
     // Without an explicit pattern, default to the majority pattern mined from
     // standard models (property_stats), falling back to SimpleList.

package/dist/tools/generateSmartReport.js

@@ -32,6 +32,7 @@ import { resolveObjectPrefix, applyObjectPrefix, getObjectSuffix, applyObjectSuf
 import { extractModelFromProject, findProjectInSolution } from '../utils/projectUtils.js';
 import { normalizeD365Xml } from '../utils/d365XmlNormalizer.js';
 import { canonicalSymbolName, lookupSymbolNocase } from '../utils/symbolLookup.js';
+import { scaffoldWriteRefusalResult } from './writeAnchorGuard.js';
 export const generateSmartReportTool = {
     name: 'generate_smart_report',
     description: `🎨 AI-driven SSRS report generation — creates up to 7 D365FO objects in one call.
@@ -221,6 +222,16 @@ export async function handleGenerateSmartReport(args, symbolIndex, bridge) {
     finalName = applyObjectSuffix(finalName, objectSuffix);
     if (finalName !== name)
         log(`Applied naming: ${name} → ${finalName}`);
+    // See generateSmartTable: the resolved model follows the ACTIVE project, the
+    // write anchor does not. A report scaffold writes several objects at once, so
+    // this is checked before any of them exists.
+    const anchorRefusal = scaffoldWriteRefusalResult({
+        objectName: finalName,
+        objectType: 'report',
+        targetModel: resolvedModel,
+    });
+    if (anchorRefusal)
+        return anchorRefusal;
     // Derived object names
     const tmpTableName = `${finalName}Tmp`;
     const contractClassName = `${finalName}Contract`;

package/dist/tools/generateSmartTable.js

@@ -13,6 +13,7 @@ import { ProjectFileManager } from './createD365File.js';
 import { extractModelFromProject, findProjectInSolution } from '../utils/projectUtils.js';
 import { normalizeD365Xml } from '../utils/d365XmlNormalizer.js';
 import { lookupSymbolNocase } from '../utils/symbolLookup.js';
+import { scaffoldWriteRefusalResult } from './writeAnchorGuard.js';
 export const generateSmartTableTool = {
     name: 'generate_smart_table',
     description: 'Generate AxTable XML with AI-driven field/index/relation suggestions based on indexed patterns. Can copy structure from existing tables, analyze table group patterns, or use field hints.',
@@ -559,6 +560,16 @@ export async function handleGenerateSmartTable(args, symbolIndex, bridge) {
     if (finalName !== name) {
         console.log(`[generateSmartTable] Applied naming: ${name} → ${finalName}`);
     }
+    // Where this scaffold would land, checked before anything is written. The
+    // model above comes from the ACTIVE project, which a get_workspace_info switch
+    // moves; writes stay anchored to the model the workspace resolved on its own.
+    const anchorRefusal = scaffoldWriteRefusalResult({
+        objectName: finalName,
+        objectType: 'table',
+        targetModel: resolvedModel,
+    });
+    if (anchorRefusal)
+        return anchorRefusal;
     // Generate standard methods (find, exist) based on primary key fields
     const generatedMethods = [];
     if (requestedMethods && requestedMethods.length > 0) {

package/dist/tools/getLabelInfo.js

@@ -5,6 +5,7 @@
  */
 import { z } from 'zod';
 import { formatLabelReference } from '../utils/labelReference.js';
+import { labelMissingOnDisk } from '../utils/labelDiskCheck.js';
 const GetLabelInfoArgsSchema = z.object({
     labelId: z
         .string()
@@ -96,6 +97,36 @@ export async function getLabelInfoTool(request, context) {
         // #33/#41: never emit `@SYS:@SYS67433` — an id that already carries its label
         // file id is a complete reference, and xppbp rejects the doubled form.
         const ref = formatLabelReference(first.labelFileId, labelId);
+        // An index row is not proof the label exists. Confirm against the .label.txt
+        // before handing back a reference the caller will paste into XML — a stale row
+        // otherwise surfaces as `Unknown label` at build time, several steps later.
+        //
+        // Every model, including Microsoft's: gating this on isCustomModel() looks
+        // right and is not, because isStandardModel() is defined as "not custom" and
+        // an unrecognised model therefore reads as Microsoft's. The shared core model
+        // whose phantom label started all this is exactly such a model, so the gate
+        // would have switched the check off in the one place it had to fire. What
+        // makes the big files affordable is the read budget in labelMissingOnDisk:
+        // the @SYS sweep that measured 17 s now gives up at 218 ms with no verdict.
+        const indexedPaths = symbolIndex
+            .getLabelFilePaths(first.labelFileId, first.model)
+            .map(p => p.filePath);
+        if (await labelMissingOnDisk(labelId, indexedPaths)) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: `⚠️ Label "${ref}" is in the symbol index but NOT in its label file on disk — ` +
+                            `treat it as NOT existing.\n` +
+                            `Checked: ${indexedPaths.join(', ')}\n\n` +
+                            `The index is ahead of the file system (a rolled-back run, a rebuild outside this ` +
+                            `server, or a checkout). Using this reference compiles to a best-practice error ` +
+                            `"Unknown label '${ref}'".\n\n` +
+                            `Create it: labels(action="create", labelId="${labelId}", labelFileId="${first.labelFileId}", ` +
+                            `model="${first.model}", translations=[{language:"en-US", text:"…"}])`,
+                    }],
+                isError: true,
+            };
+        }
         const lines = [
             `Label: ${ref}`,
             `Model: ${first.model}  |  LabelFile: ${first.labelFileId}`,

package/dist/tools/modifyD365File.d.ts

@@ -167,7 +167,7 @@ export declare function modifyD365FileTool(request: CallToolRequest, context: Xp
  *
  * Idempotent: a name that already carries the prefix — in either the underscore
  * or the bare form, case-insensitively — is left untouched, so an agent that
- * prefixes by hand does not end up with HBR_HBR_Foo.
+ * prefixes by hand does not end up with DEMO_DEMO_Foo.
  */
 export declare function applyExtensionMemberPrefix(args: Record<string, any>, objectType: string, operation: string, modelName: string): string;
 /**

package/dist/tools/modifyD365File.js

@@ -1126,7 +1126,7 @@ const ModifyD365FileArgsSchema = z.object({
     fieldMandatory: z.boolean().optional().describe('Is field mandatory'),
     fieldLabel: z.string().optional().describe('Field label'),
     fieldHelpText: z.string().optional().describe('Field help text (modify-field).'),
-    fieldEnumType: z.string().optional().describe('Enum name to set on the field (modify-field, for enum-typed fields).'),
+    fieldEnumType: z.string().optional().describe('Enum name for an enum-typed field. On add-field this replaces fieldType entirely — it writes AxTableFieldEnum + EnumType and needs no EDT. Also settable later with modify-field.'),
     fieldStringSize: z.string().optional().describe('String size to set on the field (modify-field, for string-typed fields).'),
     fields: z.array(z.object({
         name: z.string(),
@@ -1457,14 +1457,17 @@ export async function modifyD365FileTool(request, context) {
         // Ownership comes from the path's <Model> segment, not the <Package> segment
         // used above: one package can carry several models.
         const owningModel = containment.modelSegment ?? null;
-        const activeModel = getConfigManager().getModelName() ?? '';
+        // The write ANCHOR, not the active model: a get_workspace_info project switch
+        // moves reads, and must not move what this guard measures writes against.
+        const activeModel = getConfigManager().getWriteAnchorModel() ?? '';
         const crossModelRefusal = crossModelWriteRefusal({
             objectName,
             objectType,
             owningModel,
             owningPackage: containment.packageSegment ?? resolvedModelFromPath,
             activeModel,
-            explicitModelName: modelName,
+            toolSwitchedModel: getConfigManager().getToolProjectSwitch()?.forcedModel ?? null,
+            action: 'modify',
             existingExtensions: findExtensionsInModel(symbolIndex, baseObjectOf(objectName, objectType), activeModel),
         });
         if (crossModelRefusal) {
@@ -1682,7 +1685,31 @@ export async function modifyD365FileTool(request, context) {
                     // (the mapped-field path above has no fieldType at all), so the type-specific half
                     // of the contract is enforced here instead of silently falling through to a null
                     // bridge result and a generic "required parameters may be missing".
-                    if (args.fieldName && !args.fieldType) {
+                    const enumTypeArg = args.fieldEnumType?.trim() || undefined;
+                    // fieldType is an EDT NAME here. In `create` the sibling key fields[].fieldType is
+                    // the XML element name ("AxTableFieldEnum"), and that collision gets carried over
+                    // into add-field, where it used to be accepted and produce a bare AxTableFieldString
+                    // referencing a non-existent EDT — a wrong field, discovered only at build time.
+                    // Anchored on the metamodel's own container names, not on "starts with Ax
+                    // and contains Field": that broader shape also rejected any legitimate EDT
+                    // whose name happens to read that way, and refusing a valid EDT is the
+                    // same class of wrong answer this check exists to prevent.
+                    if (args.fieldType && /^Ax(Table|View|Query|Map|DataEntityView)[A-Za-z]*Field[A-Za-z0-9]*$/i.test(args.fieldType)) {
+                        return {
+                            content: [{
+                                    type: 'text',
+                                    text: `❌ fieldType="${args.fieldType}" is an XML element name, not an EDT — nothing was written.\n` +
+                                        `On add-field, fieldType is the EDT NAME (e.g. "TransDate", "ItemId"); the XML element is ` +
+                                        `chosen from fieldBaseType.\n` +
+                                        `For an enum field pass fieldEnumType="<enum name>" instead — no EDT is needed:\n` +
+                                        `  d365fo_file(action="modify", objectType="${objectType}", objectName="…", ` +
+                                        `operation="add-field", fieldName="${args.fieldName ?? 'MyField'}", fieldEnumType="MyEnum")\n` +
+                                        `\n${renderOpSpec('add-field')}`,
+                                }],
+                            isError: true,
+                        };
+                    }
+                    if (args.fieldName && !args.fieldType && !enumTypeArg) {
                         const mappedOnly = args.dataField || args.dataSource;
                         return {
                             content: [{
@@ -1690,14 +1717,53 @@ export async function modifyD365FileTool(request, context) {
                                     text: (mappedOnly
                                         ? `❌ dataField/dataSource describe a data-entity mapped field and do not apply to ` +
                                             `objectType="${objectType}" — nothing was written.\n` +
-                                            `On a table or table-extension a field needs fieldType (its EDT).\n`
-                                        : `❌ add-field on objectType="${objectType}" requires fieldType (the EDT) — ` +
-                                            `nothing was written.\n`) +
+                                            `On a table or table-extension a field needs fieldType (its EDT), or ` +
+                                            `fieldEnumType for an enum field.\n`
+                                        : `❌ add-field on objectType="${objectType}" requires fieldType (the EDT), or ` +
+                                            `fieldEnumType for an enum field — nothing was written.\n`) +
                                         `\n${renderOpSpec('add-field')}`,
                                 }],
                             isError: true,
                         };
                     }
+                    // Enum field: AxTableFieldEnum + <EnumType>, and NO EDT — an enum-typed table
+                    // field does not need one. Requiring an EDT here is what used to send callers off
+                    // building an AxEdtEnum wrapper, guessing at <Extends>, and failing the build twice
+                    // before getting there. fieldType stays accepted for the rarer "enum EDT" case.
+                    if (args.fieldName && enumTypeArg) {
+                        bridgeResult = await bridgeAddField(context.bridge, objectName, args.fieldName, 'Enum', args.fieldType, // usually undefined; an enum EDT when the caller has one
+                        args.fieldMandatory, args.fieldLabel);
+                        // EnumType is set in a second call on purpose: the bridge's AddField RPC has no
+                        // enumType parameter, while ModifyField does. Doing it here keeps this a
+                        // single tool call for the caller AND works with the bridge already deployed —
+                        // no rebuild, which is the part that silently keeps the old binary.
+                        if (bridgeResult?.success) {
+                            const enumSet = await bridgeModifyField(context.bridge, objectName, args.fieldName, { enumType: enumTypeArg });
+                            if (enumSet && !enumSet.success) {
+                                // Undo the half-written field. Two calls are not atomic, and what
+                                // they can leave behind — an AxTableFieldEnum with no enum — is a
+                                // field the caller did not ask for. Worse, the bridge's AddField
+                                // does not check for an existing field, so an agent that reads
+                                // "failed" and simply repeats the call ends up with the field
+                                // twice. Rolling back restores the pre-call state, which is the
+                                // only state a failed operation may leave.
+                                const undone = await bridgeRemoveField(context.bridge, objectName, args.fieldName);
+                                bridgeResult = {
+                                    success: false,
+                                    message: undone?.success
+                                        ? `EnumType could not be set (${enumSet.message}) — the field was rolled back and ` +
+                                            `nothing was written. Check that enum "${enumTypeArg}" exists ` +
+                                            `(get_object_info objectType="enum"), then retry add-field.`
+                                        : `Field '${args.fieldName}' was created but EnumType could not be set ` +
+                                            `(${enumSet.message}), and rolling the field back failed too. The field is an ` +
+                                            `AxTableFieldEnum with no enum — do NOT repeat add-field, it would add a SECOND ` +
+                                            `field of the same name. Fix it with operation="modify-field", ` +
+                                            `fieldEnumType="${enumTypeArg}", or remove it with operation="remove-field".`,
+                                };
+                            }
+                        }
+                        break;
+                    }
                     if (args.fieldName && args.fieldType) {
                         // fieldType is the EDT name; fieldBaseType is the primitive base type.
                         // When fieldBaseType is omitted, auto-resolve it from the symbol index so the
@@ -2190,13 +2256,29 @@ export async function modifyD365FileTool(request, context) {
         // up front instead of letting it become a build error the agent hunts by hand.
         const xppLintWarnings = lintXppSelect(args.sourceCode ?? args.methodCode ?? args.newCode);
         const xppLintNote = xppLintWarnings.length > 0 ? `\n\n${xppLintWarnings.join('\n\n')}` : '';
+        // Two BP rules fire on a field that compiles perfectly, so they are invisible
+        // until a BP run several steps later — and one of them (the label copy) then
+        // needs new labels, i.e. rework of what was just written. Say it here instead.
+        let addFieldBpNote = '';
+        if (operation === 'add-field' && (objectType === 'table' || objectType === 'table-extension')) {
+            const notes = [
+                `⚠️ BP: a table field must belong to a field group (BPErrorTableFieldNotInFieldGroup):\n` +
+                    `   d365fo_file(action="modify", objectType="${objectType}", objectName="${objectName}", ` +
+                    `operation="add-field-to-field-group", fieldName="${args.fieldName}", fieldGroupName="<group>")`,
+            ];
+            if (args.fieldEnumType) {
+                notes.push(`⚠️ BP: the field's Label must be a DIFFERENT label id than the enum's own label ` +
+                    `(BPErrorFieldLabelIsCopyOfEnumLabel) — same visible text is fine, same id is not.`);
+            }
+            addFieldBpNote = `\n\n${notes.join('\n')}`;
+        }
         return {
             content: [
                 {
                     type: 'text',
                     text: `✅ ${operation} on ${objectType} "${objectName}" — applied via IMetadataProvider.Update()\n\n` +
                         `**File:** ${actualFilePath}${addControlNote}${generationNote}${bridgeValidation}${projectMessage}\n` +
-                        `🔧 API: ${bridgeResult.message}${xppLintNote}${backupNote}` +
+                        `🔧 API: ${bridgeResult.message}${xppLintNote}${addFieldBpNote}${backupNote}` +
                         (ignoredParamsWarning ? `\n\n${ignoredParamsWarning}` : '') + `\n\n` +
                         `**Next steps:**\n- Review changes in Visual Studio\n- Build the model to validate`,
                 },
@@ -2279,7 +2361,7 @@ function findExtensionsInModel(symbolIndex, baseObject, model) {
  *
  * Idempotent: a name that already carries the prefix — in either the underscore
  * or the bare form, case-insensitively — is left untouched, so an agent that
- * prefixes by hand does not end up with HBR_HBR_Foo.
+ * prefixes by hand does not end up with DEMO_DEMO_Foo.
  */
 export function applyExtensionMemberPrefix(args, objectType, operation, modelName) {
     if (!EXTENSION_OBJECT_TYPES.has(objectType))

package/dist/tools/prefixDiagnostics.d.ts

@@ -0,0 +1,38 @@
+/**
+ * The "Prefix Configuration" section of `get_workspace_info`.
+ *
+ * Two rules decide everything here:
+ *
+ * 1. The prefix is reported for the model that WRITES land in — the write anchor
+ *    (see ConfigManager.getWriteAnchorModel). A tool-initiated project switch
+ *    moves the active project without moving that anchor, so after one the two
+ *    are different models with different prefixes; reporting the active model's
+ *    prefix would state a token no write would ever apply.
+ * 2. The reported value always carries its origin. The prefix can come from the
+ *    model's own objects, from EXTENSION_PREFIX, or from the model name, and a
+ *    bare "Effective prefix: ConFin" under "EXTENSION_PREFIX: Con" reads as
+ *    approved rather than as the disagreement it is.
+ */
+/**
+ * The model a write would actually land in.
+ *
+ * Normally the anchor: a project switch does not move writes. But when the
+ * operator has allowed writes into the switched-to model in configuration, the
+ * guard lets them through and they land in the ACTIVE model — so that is the
+ * model whose prefix a create would apply. Reporting the anchor's prefix there
+ * would be the same defect one state over.
+ */
+export declare function modelWritesLandIn(anchorModel: string | null, activeModel: string | null): string | null;
+export interface PrefixDiagnostics {
+    /** Lines for the "## Prefix Configuration" section, blank line included. */
+    lines: string[];
+    /** The prefix a write would apply — for the Extension Naming samples. */
+    effectivePrefix: string;
+}
+/**
+ * @param writeModel model writes are anchored to; the prefix is resolved for it
+ * @param readModel  model reads currently come from — differs from `writeModel`
+ *                   only while a tool project switch is in effect
+ */
+export declare function buildPrefixDiagnostics(writeModel: string | null, readModel: string | null): PrefixDiagnostics;
+//# sourceMappingURL=prefixDiagnostics.d.ts.map