genexus-mcp 3.6.0 → 3.7.0

package/cli/lib/config.js

@@ -33,6 +33,7 @@ function generateNeutralConfig(gxPath, { workerPath, gatewayMode = 'stdio-isolat
         Server: {
             HttpPort: 0,
             McpStdio: true,
+            WorkerSharingMode: 'isolated',
             SessionIdleTimeoutMinutes: 10,
             WorkerIdleTimeoutMinutes: 5,
             EmitStructuredContent: false,
@@ -70,6 +71,10 @@ function getToolDefinitionsPath() {
         // 3. Fallback alongside the CLI itself (defensive — for unusual layouts).
         path.join(__dirname, '..', '..', 'publish', 'tool_definitions.json')
     ];
+    // An explicit gateway override is usually a fixed-path or checkout install.
+    // Do not hide a missing sibling artifact with this source tree's copy: the
+    // Gateway loads the file next to its own executable at runtime.
+    if (process.env.GENEXUS_MCP_GATEWAY_EXE) return candidates[0];
     for (const candidate of candidates) {
         if (fs.existsSync(candidate)) return candidate;
     }
@@ -107,12 +112,17 @@ function getGeneXusVersionCatalog() {
         legacyMajors: [
             { major: '10.3', displayName: 'GeneXus Evolution 3', defaultInstallPath: 'C:\\Program Files (x86)\\GeneXus\\GeneXusXEv3' },
             { major: '9', displayName: 'GeneXus 9.0', defaultInstallPath: 'C:\\Program Files (x86)\\ARTech\\GeneXus\\GeneXus 9.0' },
-            { major: '8', displayName: 'GeneXus 8.0', defaultInstallPath: 'C:\\Program Files (x86)\\ARTech\\GeneXus\\GeneXus 8.0' }
+            { major: '8', displayName: 'GeneXus 8.0', defaultInstallPath: 'C:\\Program Files (x86)\\ARTech\\GeneXus\\gxw80' }
         ],
         source: 'built-in-fallback'
     };
 }
 
+function hasGeneXusExecutable(gxPath) {
+    return Boolean(gxPath) && ['genexus.exe', 'gx.exe', 'gxw32.exe']
+        .some((name) => fs.existsSync(path.join(gxPath, name)));
+}
+
 function getGeneXusCatalogEntries(preferredMajor = null) {
     const catalog = getGeneXusVersionCatalog();
     const all = [...catalog.supportedMajors, ...(catalog.legacyMajors || [])];
@@ -153,13 +163,31 @@ function discoverGeneXusFromRegistry(preferredMajor = null) {
                         const match = out.match(/InstallationDirectory\s+REG_SZ\s+(.+?)\r?\n/i);
                         if (match) {
                             const candidate = match[1].trim().replace(/[\\/]+$/, '');
-                            if (candidate && fs.existsSync(path.join(candidate, 'genexus.exe')) && matchesPreferredGeneXusMajor(candidate, preferredMajor)) {
+                            if (candidate && hasGeneXusExecutable(candidate) && matchesPreferredGeneXusMajor(candidate, preferredMajor)) {
                                 return candidate;
                             }
                         }
                     } catch {
                     }
                 }
+                // Classic ARTech installers store GX8/GX9 under Setup\\<version>
+                // and expose the actual IDE root in the Install value rather
+                // than the modern GeneXus <major>\\InstallationDirectory key.
+                for (const setupVersion of (entry.legacySetupVersions || [])) {
+                    const key = `${hive}\\\\${setupVersion}`;
+                    try {
+                        const out = execFileSync('reg.exe', ['query', key, '/v', 'Install'], {
+                            encoding: 'utf8',
+                            stdio: ['ignore', 'pipe', 'ignore'],
+                            windowsHide: true,
+                            timeout: 3000
+                        });
+                        const installLine = out.split(String.fromCharCode(10)).map((line) => line.trim()).find((line) => /^Install\s+REG_SZ\s+/i.test(line));
+                        const candidate = installLine ? installLine.replace(/^Install\s+REG_SZ\s+/i, '').trim() : null;
+                        if (candidate && hasGeneXusExecutable(candidate) && matchesPreferredGeneXusMajor(candidate, preferredMajor)) return candidate;
+                    } catch {
+                    }
+                }
                 for (const legacyVersion of (entry.legacyRegistryVersions || [])) {
                     const key = `${hive}\\GeneXus\\${legacyVersion}`;
                     try {
@@ -172,7 +200,7 @@ function discoverGeneXusFromRegistry(preferredMajor = null) {
                         const match = out.match(/InstallPath\s+REG_SZ\s+(.+?)\r?\n/i);
                         if (match) {
                             const candidate = match[1].trim().replace(/[\\/]+$/, '');
-                            if (candidate && fs.existsSync(path.join(candidate, 'genexus.exe')) && matchesPreferredGeneXusMajor(candidate, preferredMajor)) return candidate;
+                            if (candidate && hasGeneXusExecutable(candidate) && matchesPreferredGeneXusMajor(candidate, preferredMajor)) return candidate;
                         }
                     } catch {
                     }
@@ -187,7 +215,7 @@ function discoverGeneXusFromRegistry(preferredMajor = null) {
 function discoverGeneXusInstallation(preferredMajor = null) {
     if (process.env.GENEXUS_HOME) {
         const candidate = process.env.GENEXUS_HOME.replace(/[\\/]+$/, '');
-        if (fs.existsSync(path.join(candidate, 'genexus.exe')) && matchesPreferredGeneXusMajor(candidate, preferredMajor)) return candidate;
+        if (hasGeneXusExecutable(candidate) && matchesPreferredGeneXusMajor(candidate, preferredMajor)) return candidate;
     }
 
     const fromRegistry = discoverGeneXusFromRegistry(preferredMajor);
@@ -205,7 +233,11 @@ function discoverGeneXusInstallation(preferredMajor = null) {
     const entries = getGeneXusCatalogEntries(preferredMajor);
     const seen = new Set();
     for (const base of programDirs) {
-        const root = path.join(base, 'GeneXus');
+        const roots = [
+            path.join(base, 'GeneXus'),
+            path.join(base, 'Artech', 'GeneXus')
+        ];
+        for (const root of roots) {
         const key = root.toLowerCase();
         if (seen.has(key)) continue;
         seen.add(key);
@@ -217,7 +249,7 @@ function discoverGeneXusInstallation(preferredMajor = null) {
             for (const ver of candidateNames) {
                 if (!ver) continue;
                 const candidate = path.join(root, ver);
-                if (fs.existsSync(path.join(candidate, 'genexus.exe')) && matchesPreferredGeneXusMajor(candidate, preferredMajor)) {
+                if (hasGeneXusExecutable(candidate) && matchesPreferredGeneXusMajor(candidate, preferredMajor)) {
                     return candidate;
                 }
             }
@@ -230,13 +262,14 @@ function discoverGeneXusInstallation(preferredMajor = null) {
                     const majorMatch = entry.match(/^GeneXus\s*(\d+)/i);
                     if (majorMatch && !entries.some((item) => String(item.major) === majorMatch[1])) continue;
                     const candidate = path.join(root, entry);
-                    if (fs.existsSync(path.join(candidate, 'genexus.exe')) && matchesPreferredGeneXusMajor(candidate, preferredMajor)) {
+                    if (hasGeneXusExecutable(candidate) && matchesPreferredGeneXusMajor(candidate, preferredMajor)) {
                         return candidate;
                     }
                 }
             }
         } catch {
         }
+        }
     }
 
     const fromPath = discoverGeneXusFromPath(preferredMajor);
@@ -249,15 +282,22 @@ function discoverGeneXusFromPath(preferredMajor = null) {
     if (process.platform !== 'win32') return null;
     try {
         const { execFileSync } = require('child_process');
-        const out = execFileSync('where.exe', ['genexus.exe'], {
-            encoding: 'utf8',
-            stdio: ['ignore', 'pipe', 'ignore'],
-            windowsHide: true,
-            timeout: 3000
-        });
-        const first = out.split(/\r?\n/).map((s) => s.trim()).find(Boolean);
-        if (first && fs.existsSync(first) && matchesPreferredGeneXusMajor(path.dirname(first), preferredMajor)) {
-            return path.dirname(first);
+        for (const executable of ['genexus.exe', 'gx.exe', 'gxw32.exe']) {
+            let out;
+            try {
+                out = execFileSync('where.exe', [executable], {
+                    encoding: 'utf8',
+                    stdio: ['ignore', 'pipe', 'ignore'],
+                    windowsHide: true,
+                    timeout: 3000
+                });
+            } catch {
+                continue;
+            }
+            const first = out.split('\n').map((s) => s.trim()).find(Boolean);
+            if (first && fs.existsSync(first) && matchesPreferredGeneXusMajor(path.dirname(first), preferredMajor)) {
+                return path.dirname(first);
+            }
         }
     } catch {
     }
@@ -344,7 +384,9 @@ function discoverKnowledgeBases(cwd, { maxResults = 25, scanDepth = 2 } = {}) {
 function directoryLooksLikeKnowledgeBase(dir) {
     try {
         const files = fs.readdirSync(dir);
-        return files.some((f) => f.toLowerCase().endsWith('.gxw') || f.toLowerCase() === 'knowledgebase.connection');
+        if (files.some((f) => f.toLowerCase().endsWith('.gxw') || f.toLowerCase() === 'knowledgebase.connection')) return true;
+        const classicMarkers = new Set(['data001', 'gxspc001', 'kbdata', 'attribut.dat', 'att.xpw', 'objects.dat', 'objects.idx']);
+        return files.filter((f) => classicMarkers.has(f.toLowerCase())).length >= 2;
     } catch {
         return false;
     }
@@ -586,8 +628,11 @@ function migrateLegacyConfig(sourcePath, targetPath, { rejectNonMigratable = fal
 
 function resolveConfigPathNoMutate(cwd) {
     const cwdConfigPath = path.join(cwd, 'config.json');
-    if (process.env.GX_CONFIG_PATH && fs.existsSync(process.env.GX_CONFIG_PATH)) {
-        return process.env.GX_CONFIG_PATH;
+    // Match the Gateway: an explicit GX_CONFIG_PATH is authoritative even when
+    // the file is missing, so diagnostics do not silently inspect an unrelated
+    // cwd config while the runtime fails on the explicit path.
+    if (process.env.GX_CONFIG_PATH) {
+        return path.resolve(process.env.GX_CONFIG_PATH);
     }
     if (fs.existsSync(cwdConfigPath)) {
         return cwdConfigPath;
@@ -1910,6 +1955,9 @@ function readGeneXusInstallationIdentity(gxPath, options = {}) {
     if (!executableVersion) {
         executableVersion = readExecutableVersion(path.join(gxPath, 'gx.exe'));
     }
+    if (!executableVersion) {
+        executableVersion = readExecutableVersion(path.join(gxPath, 'gxw32.exe'));
+    }
     if (executableVersion) {
         return {
             version: executableVersion,
@@ -1996,6 +2044,7 @@ function readGeneXusKbIdentity(kbPath) {
 
     let gxwFiles;
     let gxiFiles = [];
+    let classicMarkerCount = 0;
     try {
         const allFiles = fs.readdirSync(kbPath);
         gxwFiles = allFiles
@@ -2004,6 +2053,8 @@ function readGeneXusKbIdentity(kbPath) {
         gxiFiles = allFiles
             .filter((fileName) => fileName.toLowerCase().endsWith('.gxi'))
             .map((fileName) => path.join(kbPath, fileName));
+        const classicMarkers = new Set(['data001', 'gxspc001', 'kbdata', 'attribut.dat', 'att.xpw', 'objects.dat', 'objects.idx']);
+        classicMarkerCount = allFiles.filter((fileName) => classicMarkers.has(fileName.toLowerCase())).length;
     } catch {
         return { version: null, major: null, source: 'unavailable', reason: 'unreadable-kb-path' };
     }
@@ -2011,6 +2062,9 @@ function readGeneXusKbIdentity(kbPath) {
         if (gxiFiles.length > 0) {
             return { version: '9.0', major: '9', source: 'gxi-classic', reason: null };
         }
+        if (classicMarkerCount >= 2) {
+            return { version: null, major: null, source: 'classic-dat', reason: 'classic-generation-requires-provider' };
+        }
         return { version: null, major: null, source: 'unavailable', reason: 'no-gxw' };
     }
     if (gxwFiles.length > 1) return { version: null, major: null, source: 'unavailable', reason: 'multiple-gxw' };
@@ -2032,34 +2086,65 @@ function readGeneXusKbIdentity(kbPath) {
     }
 }
 
-function compareGeneXusKbAndInstallation(kbPath, gxPath) {
+function compareGeneXusKbAndInstallation(kbPath, gxPath, options = {}) {
     const kb = readGeneXusKbIdentity(kbPath);
-    const gx = readGeneXusInstallationIdentity(gxPath);
+    const gx = readGeneXusInstallationIdentity(gxPath, options);
     let status = 'unresolved';
-    if (kb.major && gx.major) status = kb.major === gx.major ? 'match' : 'mismatch';
+    // A classic .gxi is shared by the GX8/GX9 family and does not carry a
+    // reliable generation marker. Do not turn the historical default of 9
+    // into a false GX8-vs-GX9 mismatch; the provider open is the authority.
+    if ((kb.source === 'gxi-classic' || kb.source === 'classic-dat') && (gx.major === '8' || gx.major === '9')) {
+        status = 'unresolved';
+    } else if (kb.major && gx.major) {
+        status = kb.major === gx.major ? 'match' : 'mismatch';
+    }
     return { status, kb, gx };
 }
 
 function normalizeKbCatalog(raw) {
+    const normalized = {};
+    const entries = {};
+    const add = (name, value) => {
+        if (typeof name !== 'string' || !name) return;
+        if (typeof value === 'string' && value) {
+            normalized[name] = value;
+            return;
+        }
+        if (!value || typeof value !== 'object') return;
+        const kbPath = typeof value.path === 'string' ? value.path : value.Path;
+        if (typeof kbPath !== 'string' || !kbPath) return;
+        normalized[name] = kbPath;
+        const metadata = { alias: name, path: kbPath };
+        let hasLegacyMetadata = false;
+        for (const [source, target] of [['driver', 'driver'], ['Driver', 'driver'], ['installationPath', 'installationPath'], ['InstallationPath', 'installationPath'], ['major', 'major'], ['Major', 'major']]) {
+            if (typeof value[source] === 'string' && value[source]) {
+                metadata[target] = value[source];
+                hasLegacyMetadata = true;
+            }
+        }
+        if (hasLegacyMetadata) entries[name] = metadata;
+    };
+
     if (Array.isArray(raw)) {
-        const normalized = {};
         for (const entry of raw) {
             if (!entry || typeof entry !== 'object') continue;
             const name = typeof entry.alias === 'string' ? entry.alias : entry.Alias;
-            const kbPath = typeof entry.path === 'string' ? entry.path : entry.Path;
-            if (typeof name === 'string' && name && typeof kbPath === 'string' && kbPath) {
-                normalized[name] = kbPath;
-            }
+            add(name, entry);
         }
+        Object.defineProperty(normalized, '__entries', { value: entries, enumerable: false, writable: true });
         return normalized;
     }
 
-    return raw && typeof raw === 'object' ? raw : {};
+    if (raw && typeof raw === 'object') {
+        for (const [name, value] of Object.entries(raw)) add(name, value);
+    }
+    Object.defineProperty(normalized, '__entries', { value: entries, enumerable: false, writable: true });
+    return normalized;
 }
 
-function readKbCatalog(configPath) {
-    if (!configPath) return { kbs: {}, activeKb: null, kbPath: null };
-    const cfg = readJsonFileSafe(configPath);
+function readKbCatalog(configPath, configOverride = undefined) {
+    if (!configPath && configOverride === undefined) return { kbs: {}, activeKb: null, kbPath: null };
+    const cfg = configOverride === undefined ? readJsonFileSafe(configPath) : configOverride;
     if (!cfg) return { kbs: {}, activeKb: null, kbPath: null };
     const env = cfg.Environment || {};
     const activeKb = typeof env.ActiveKb === 'string' && env.ActiveKb
@@ -2075,7 +2160,19 @@ function readKbCatalog(configPath) {
 function writeKbCatalog(configPath, { kbs, activeKb, kbPath }) {
     const cfg = readJsonFileSafe(configPath) || {};
     cfg.Environment = cfg.Environment || {};
-    cfg.Environment.KBs = kbs;
+    const serializedKbs = {};
+    for (const [name, kbPathValue] of Object.entries(kbs || {})) {
+        const metadata = kbs.__entries && kbs.__entries[name];
+        serializedKbs[name] = metadata
+            ? {
+                Path: kbPathValue,
+                ...(metadata.driver ? { Driver: metadata.driver } : {}),
+                ...(metadata.installationPath ? { InstallationPath: metadata.installationPath } : {}),
+                ...(metadata.major ? { Major: metadata.major } : {})
+            }
+            : kbPathValue;
+    }
+    cfg.Environment.KBs = serializedKbs;
     if (activeKb) {
         cfg.Environment.ActiveKb = activeKb;
         cfg.Environment.DefaultKb = activeKb;

package/cli/run.test.js

@@ -20,9 +20,13 @@ const {
     getLauncher,
     getGeneXusMajor,
     getGeneXusCatalogEntries,
+    discoverGeneXusInstallation,
     readGeneXusInstallationIdentity,
+    directoryLooksLikeKnowledgeBase,
     readGeneXusKbIdentity,
     compareGeneXusKbAndInstallation,
+    readKbCatalog,
+    switchActiveKb,
     patchClientConfig
 } = require('./lib/config');
 const { handleInit, resolveMcpSmokeTarget } = require('./commands/axi');
@@ -553,6 +557,54 @@ test('GeneXus installation identity falls back to executable metadata', () => {
     }
 });
 
+test('classic GeneXus installation identity reads gx.exe metadata', () => {
+    const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'genexus-mcp-classic-version-'));
+    try {
+        fs.writeFileSync(path.join(tempRoot, 'gx.exe'), 'not-a-real-executable');
+        const identity = readGeneXusInstallationIdentity(tempRoot, {
+            readExecutableVersion: (exePath) => exePath.endsWith('gx.exe') ? '9.0.123' : null
+        });
+        assert.deepEqual(identity, {
+            version: '9.0.123',
+            major: '9',
+            source: 'executable-metadata'
+        });
+    } finally {
+        removeTempPath(tempRoot, { recursive: true, force: true });
+    }
+});
+
+test('GeneXus 8 installation identity reads gxw32.exe metadata', () => {
+    const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'genexus-mcp-gx8-version-'));
+    try {
+        fs.writeFileSync(path.join(tempRoot, 'gxw32.exe'), 'not-a-real-executable');
+        const identity = readGeneXusInstallationIdentity(tempRoot, {
+            readExecutableVersion: (exePath) => exePath.endsWith('gxw32.exe') ? '8.0.0.632' : null
+        });
+        assert.deepEqual(identity, {
+            version: '8.0.0.632',
+            major: '8',
+            source: 'executable-metadata'
+        });
+    } finally {
+        removeTempPath(tempRoot, { recursive: true, force: true });
+    }
+});
+
+test('classic GeneXus installation discovery accepts GENEXUS_HOME with gx.exe', () => {
+    const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'genexus-mcp-classic-home-'));
+    const previousHome = process.env.GENEXUS_HOME;
+    try {
+        fs.writeFileSync(path.join(tempRoot, 'gx.exe'), 'not-a-real-executable');
+        process.env.GENEXUS_HOME = tempRoot;
+        assert.equal(discoverGeneXusInstallation(), tempRoot);
+    } finally {
+        if (previousHome === undefined) delete process.env.GENEXUS_HOME;
+        else process.env.GENEXUS_HOME = previousHome;
+        removeTempPath(tempRoot, { recursive: true, force: true });
+    }
+});
+
 test('GeneXus installation identity ignores an invalid version file when executable metadata is valid', () => {
     const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'genexus-mcp-invalid-version-'));
     try {
@@ -660,6 +712,72 @@ test('KB identity reads GeneXus 9.0 classic major from gxi when gxw is absent',
     }
 });
 
+test('classic DAT KB identity recognizes GX8/9 model markers without inventing a major', () => {
+    const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'genexus-mcp-kb-classic-dat-'));
+    try {
+        for (const marker of ['DATA001', 'GXSPC001', 'ATTRIBUT.DAT', 'ATT.XPW']) {
+            fs.writeFileSync(path.join(tempRoot, marker), 'classic');
+        }
+        const identity = readGeneXusKbIdentity(tempRoot);
+        assert.equal(identity.major, null);
+        assert.equal(identity.source, 'classic-dat');
+        assert.equal(identity.reason, 'classic-generation-requires-provider');
+        assert.equal(directoryLooksLikeKnowledgeBase(tempRoot), true);
+    } finally {
+        removeTempPath(tempRoot, { recursive: true, force: true });
+    }
+});
+
+test('KB catalog edits preserve per-KB legacy driver metadata', () => {
+    const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'genexus-mcp-kb-catalog-'));
+    const configPath = path.join(tempRoot, 'config.json');
+    try {
+        fs.writeFileSync(configPath, JSON.stringify({
+            Environment: {
+                KBs: {
+                    sect80: {
+                        Path: 'D:\\\\GX80\\\\SECT',
+                        Driver: 'com-gxpublic',
+                        InstallationPath: 'C:\\\\gxw80',
+                        Major: '8'
+                    }
+                },
+                ActiveKb: 'sect80'
+            }
+        }));
+
+        const catalog = readKbCatalog(configPath);
+        assert.equal(catalog.kbs.sect80, 'D:\\\\GX80\\\\SECT');
+        assert.equal(Object.keys(catalog.kbs).length, 1);
+        const switched = switchActiveKb(configPath, { name: 'sect80' });
+        assert.equal(switched.ok, true);
+        const persisted = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+        assert.equal(persisted.Environment.KBs.sect80.Driver, 'com-gxpublic');
+        assert.equal(persisted.Environment.KBs.sect80.InstallationPath, 'C:\\\\gxw80');
+        assert.equal(persisted.Environment.KBs.sect80.Major, '8');
+    } finally {
+        removeTempPath(tempRoot, { recursive: true, force: true });
+    }
+});
+
+test('classic gxi identity does not invent a GX8/GX9 mismatch before provider open', () => {
+    const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'genexus-mcp-kb-gxi-compare-'));
+    const gx8Root = fs.mkdtempSync(path.join(os.tmpdir(), 'genexus-mcp-gx8-compare-'));
+    try {
+        fs.writeFileSync(path.join(tempRoot, 'Legacy.gxi'), 'classic-kb');
+        fs.writeFileSync(path.join(gx8Root, 'gxw32.exe'), 'not-a-real-executable');
+        const compatibility = compareGeneXusKbAndInstallation(tempRoot, gx8Root, {
+            readExecutableVersion: (exePath) => exePath.endsWith('gxw32.exe') ? '8.0.0.632' : null
+        });
+        assert.equal(compatibility.status, 'unresolved');
+        assert.equal(compatibility.kb.source, 'gxi-classic');
+        assert.equal(compatibility.gx.major, '8');
+    } finally {
+        removeTempPath(tempRoot, { recursive: true, force: true });
+        removeTempPath(gx8Root, { recursive: true, force: true });
+    }
+});
+
 test('init rejects a known KB and SDK major mismatch before writing config', () => {
     const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'genexus-mcp-mismatch-'));
     const kbDir = path.join(tempRoot, 'kb17');
@@ -1056,6 +1174,146 @@ test('--fields validation returns usage error for invalid doctor field', () => {
     assert.equal(parsed.error.code, 'usage_error');
 });
 
+test('doctor client_config_sync describes the effective gateway and its source', () => {
+    const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'genexus-mcp-doctor-gateway-source-'));
+    try {
+        const env = sandboxHomeEnv(tempRoot);
+        const configuredGateway = path.join(tempRoot, 'checkout', 'publish', 'GxMcp.Gateway.exe');
+        const mismatchedGateway = path.join(tempRoot, 'other', 'GxMcp.Gateway.exe');
+        const clientConfig = path.join(tempRoot, '.gemini', 'settings.json');
+        fs.mkdirSync(path.dirname(configuredGateway), { recursive: true });
+        fs.mkdirSync(path.dirname(clientConfig), { recursive: true });
+        fs.writeFileSync(configuredGateway, '');
+        fs.writeFileSync(clientConfig, JSON.stringify({
+            mcpServers: {
+                genexus18mcp: { command: configuredGateway, args: [] }
+            }
+        }));
+
+        const overrideEnv = { ...env, GENEXUS_MCP_GATEWAY_EXE: configuredGateway };
+        const matching = runCli(['doctor', '--format', 'json'], { env: overrideEnv });
+        assert.equal(matching.status, 0);
+        const matchingCheck = JSON.parse(matching.stdout).ok.checks.find((c) => c.id === 'client_config_sync');
+        assert.ok(matchingCheck);
+        assert.equal(matchingCheck.status, 'pass');
+        assert.ok(matchingCheck.detail.includes(`Configured Gateway: ${configuredGateway} (source: GENEXUS_MCP_GATEWAY_EXE)`));
+        assert.doesNotMatch(matchingCheck.detail, /npm-package gateway exe/);
+
+        fs.writeFileSync(clientConfig, JSON.stringify({
+            mcpServers: {
+                genexus18mcp: { command: mismatchedGateway, args: [] }
+            }
+        }));
+        const mismatching = runCli(['doctor', '--format', 'json'], { env: overrideEnv });
+        assert.equal(mismatching.status, 0);
+        const mismatchingCheck = JSON.parse(mismatching.stdout).ok.checks.find((c) => c.id === 'client_config_sync');
+        assert.ok(mismatchingCheck);
+        assert.equal(mismatchingCheck.status, 'warn');
+        assert.ok(mismatchingCheck.detail.includes(`Configured Gateway: ${configuredGateway} (source: GENEXUS_MCP_GATEWAY_EXE)`));
+        assert.doesNotMatch(mismatchingCheck.detail, /this npm package's bundled exe/);
+    } finally {
+        removeTempPath(tempRoot, { recursive: true, force: true });
+    }
+});
+
+test('doctor fails closed when GX_CONFIG_PATH points at a missing file', () => {
+    const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'genexus-mcp-doctor-config-selection-'));
+    try {
+        const cwdConfig = path.join(tempRoot, 'config.json');
+        const missingConfig = path.join(tempRoot, 'missing.json');
+        fs.writeFileSync(cwdConfig, JSON.stringify({ Environment: { KBPath: 'C:\\wrong-context' } }));
+
+        const result = runCli(['doctor', '--mcp-smoke', '--format', 'json'], {
+            cwd: tempRoot,
+            env: {
+                ...sandboxHomeEnv(tempRoot),
+                GX_CONFIG_PATH: missingConfig,
+                GENEXUS_MCP_GATEWAY_EXE: process.execPath
+            }
+        });
+        assert.equal(result.status, 0);
+        const checks = JSON.parse(result.stdout).ok.checks;
+        const configCheck = checks.find((c) => c.id === 'config_file');
+        const probeCheck = checks.find((c) => c.id === 'gateway_spawn_probe');
+        const smokeCheck = checks.find((c) => c.id === 'mcp_smoke');
+        assert.ok(configCheck);
+        assert.equal(configCheck.status, 'fail');
+        assert.ok(configCheck.detail.includes(missingConfig));
+        assert.ok(probeCheck);
+        assert.equal(probeCheck.status, 'not_applicable');
+        assert.ok(smokeCheck);
+        assert.equal(smokeCheck.status, 'not_applicable');
+    } finally {
+        removeTempPath(tempRoot, { recursive: true, force: true });
+    }
+});
+
+test('doctor rejects malformed tool definitions instead of reporting only file presence', () => {
+    const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'genexus-mcp-doctor-tool-defs-'));
+    try {
+        const configPath = path.join(tempRoot, 'config.json');
+        const toolDefinitionsPath = path.join(tempRoot, 'tool_definitions.json');
+        fs.writeFileSync(configPath, JSON.stringify({}));
+        fs.writeFileSync(toolDefinitionsPath, '{ invalid json');
+
+        const result = runCli(['doctor', '--format', 'json'], {
+            cwd: tempRoot,
+            env: {
+                ...sandboxHomeEnv(tempRoot),
+                GX_CONFIG_PATH: configPath,
+                GENEXUS_MCP_GATEWAY_EXE: path.join(tempRoot, 'missing', 'GxMcp.Gateway.exe'),
+                GENEXUS_MCP_TOOL_DEFINITIONS: toolDefinitionsPath
+            }
+        });
+        assert.equal(result.status, 0);
+        const check = JSON.parse(result.stdout).ok.checks.find((c) => c.id === 'tool_definitions');
+        assert.ok(check);
+        assert.equal(check.status, 'fail');
+        assert.ok(check.detail.includes(toolDefinitionsPath));
+    } finally {
+        removeTempPath(tempRoot, { recursive: true, force: true });
+    }
+});
+
+test('doctor reports strict KB catalog ambiguity instead of ignoring Environment.KBs', () => {
+    const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'genexus-mcp-doctor-kb-catalog-'));
+    try {
+        const kbOne = path.join(tempRoot, 'kb-one');
+        const kbTwo = path.join(tempRoot, 'kb-two');
+        const configPath = path.join(tempRoot, 'config.json');
+        fs.mkdirSync(kbOne, { recursive: true });
+        fs.mkdirSync(kbTwo, { recursive: true });
+        fs.writeFileSync(path.join(kbOne, 'model.gxw'), '');
+        fs.writeFileSync(path.join(kbTwo, 'model.gxw'), '');
+        fs.writeFileSync(configPath, JSON.stringify({
+            GatewayMode: 'stdio-isolated',
+            Environment: {
+                ResolutionPolicy: 'strict',
+                KBs: {
+                    one: { Path: kbOne },
+                    two: { Path: kbTwo }
+                }
+            }
+        }));
+
+        const result = runCli(['doctor', '--format', 'json'], {
+            cwd: tempRoot,
+            env: {
+                ...sandboxHomeEnv(tempRoot),
+                GX_CONFIG_PATH: configPath,
+                GENEXUS_MCP_GATEWAY_EXE: path.join(tempRoot, 'missing', 'GxMcp.Gateway.exe')
+            }
+        });
+        assert.equal(result.status, 0);
+        const check = JSON.parse(result.stdout).ok.checks.find((c) => c.id === 'kb_catalog');
+        assert.ok(check);
+        assert.equal(check.status, 'warn');
+        assert.match(check.detail, /neither ActiveKb nor DefaultKb/);
+    } finally {
+        removeTempPath(tempRoot, { recursive: true, force: true });
+    }
+});
+
 test('doctor finds tool_definitions.json next to the gateway exe (not just dev-tree)', () => {
     // Regression for v2.6.6 bug: getToolDefinitionsPath() hard-coded the dev-tree
     // location, so every installed copy reported "tool_definitions.json is missing"

package/config/gx-versions.json

@@ -63,15 +63,17 @@
       "driver": "com-gxpublic",
       "defaultInstallPath": "C:\\Program Files (x86)\\ARTech\\GeneXus\\GeneXus 9.0",
       "registryNames": ["GeneXus 9.0"],
-      "legacyRegistryVersions": ["9.0"]
+      "legacyRegistryVersions": ["9.0"],
+      "legacySetupVersions": ["90"]
     },
     {
       "major": "8",
       "displayName": "GeneXus 8.0",
       "driver": "com-gxpublic",
-      "defaultInstallPath": "C:\\Program Files (x86)\\ARTech\\GeneXus\\GeneXus 8.0",
+      "defaultInstallPath": "C:\\Program Files (x86)\\ARTech\\GeneXus\\gxw80",
       "registryNames": ["GeneXus 8.0"],
-      "legacyRegistryVersions": ["8.0"]
+      "legacyRegistryVersions": ["8.0"],
+      "legacySetupVersions": ["80"]
     }
   ]
 }

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "genexus-mcp",
-  "version": "3.6.0",
+  "version": "3.7.0",
   "mcpName": "io.github.lennix1337/genexus",
-  "description": "GeneXus 16, GeneXus 17, GeneXus 18 MCP server — read, edit, and analyze Knowledge Base objects directly from Claude, Cursor, and other AI agents over the Model Context Protocol.",
+  "description": "GeneXus 16, GeneXus 17, GeneXus 18 MCP server with native SDK support; basic legacy compatibility for GeneXus Evolution 3, GeneXus Evolution 2, GeneXus Evolution 1, GeneXus 15, GeneXus 9.0, GeneXus 8.0 via com-gxpublic and dotnet-reflection drivers — read, edit, and analyze Knowledge Base objects directly from Claude, Cursor, and other AI agents over the Model Context Protocol.",
   "keywords": [
     "mcp",
     "mcp-server",

package/publish/GxMcp.Gateway.deps.json

@@ -7,7 +7,7 @@
   "targets": {
     ".NETCoreApp,Version=v10.0": {},
     ".NETCoreApp,Version=v10.0/win-x64": {
-      "GxMcp.Gateway/3.6.0": {
+      "GxMcp.Gateway/3.7.0": {
         "dependencies": {
           "Newtonsoft.Json": "13.0.3",
           "System.Management": "10.0.5",
@@ -66,7 +66,7 @@
     }
   },
   "libraries": {
-    "GxMcp.Gateway/3.6.0": {
+    "GxMcp.Gateway/3.7.0": {
       "type": "project",
       "serviceable": false,
       "sha512": ""